home *** CD-ROM | disk | FTP | other *** search
/ InterCD 2000 September / september_2000.iso / intercd / root / ^Linux / cfengine-1.5.3 / src / install.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-09-24  |  102.9 KB  |  4,738 lines
  1. /* cfengine for GNU
  2.  
  3.         Copyright (C) 1995
  4.         Free Software Foundation, Inc.
  5.  
  6.    This file is part of GNU cfengine - written and maintained 
  7.    by Mark Burgess, Dept of Computing and Engineering, Oslo College,
  8.    Dept. of Theoretical physics, University of Oslo
  9.  
  10.    This program is free software; you can redistribute it and/or modify it
  11.    under the terms of the GNU General Public License as published by the
  12.    Free Software Foundation; either version 2, or (at your option) any
  13.    later version.
  14.  
  15.    This program is distributed in the hope that it will be useful,
  16.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.    GNU General Public License for more details.
  19.  
  20.   You should have received a copy of the GNU General Public License
  21.   along with this program; if not, write to the Free Software
  22.   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
  23.  
  24. */
  25.  
  26.  
  27. /*******************************************************************/
  28. /*                                                                 */
  29. /* Routines which install actions parsed by the parser             */
  30. /*                                                                 */
  31. /* Derived from parse.c (Parse object)                             */
  32. /*                                                                 */
  33. /*******************************************************************/
  34.  
  35. #define INET
  36.  
  37. #include "cf.defs.h"
  38. #include "cf.extern.h"
  39.  
  40. /*******************************************************************/
  41.  
  42. InstallLocalInfo (varvalue)
  43.  
  44. char *varvalue;
  45.  
  46. { int number = -1;
  47.   char buffer[maxvarsize], command[maxvarsize], *sp;
  48.   char value[bufsize];
  49.   
  50. if ( ! IsInstallable(CLASSBUFF))
  51.    {
  52.    Debug1("Not installing %s, no match\n",value);
  53.    return;
  54.    }
  55.  
  56. bzero(value,bufsize);
  57.  
  58. ExpandVarstring(varvalue,value,NULL);
  59.  
  60. if (strncmp(value,"exec ",5) == 0)
  61.    {
  62.    for (sp = value+4; *sp == ' '; sp++)
  63.       {
  64.       }
  65.  
  66.    if (*sp == '/')
  67.       {
  68.       strncpy(command,sp,maxvarsize);
  69.       GetExecOutput(command,value);
  70.       Chop(value);
  71.       value[maxvarsize-1] = '\0';  /* Truncate to maxvarsize */
  72.       }
  73.    else
  74.       {
  75.       Warning("Exec string in control did not specify an absolute path");
  76.       }
  77.    }
  78.  
  79. Debug1("\n(Action is control, storing variable [%s=%s])\n",CURRENTITEM,value);
  80.  
  81. switch (ScanVariable(CURRENTITEM))
  82.    {
  83.    case cfsite:
  84.    case cffaculty:  if (!IsDefinedClass(CLASSBUFF))
  85.                       {
  86.               break;
  87.               }
  88.  
  89.                     if (VFACULTY[0] != '\0')
  90.                        {
  91.                        yyerror("Multiple declaration of variable faculty / site");
  92.                        FatalError("Redefinition of basic system variable");
  93.                        }
  94.  
  95.                     strcpy(VFACULTY,value);
  96.                     break;
  97.  
  98.    case cfdomain:  if (!IsDefinedClass(CLASSBUFF))
  99.                       {
  100.               break;
  101.               }
  102.  
  103.                    strcpy(VDOMAIN,value);
  104.           
  105.            if (!strstr(VSYSNAME.nodename,ToLowerStr(VDOMAIN)))
  106.               {
  107.               sprintf(VFQNAME,"%s.%s",VSYSNAME.nodename,ToLowerStr(VDOMAIN));
  108.               strcpy(VUQNAME,VSYSNAME.nodename);
  109.               }
  110.            else
  111.               {
  112.               int n = 0;
  113.               strcpy(VFQNAME,VSYSNAME.nodename);
  114.               
  115.               while(VSYSNAME.nodename[n++] != '.')
  116.             {
  117.             }
  118.  
  119.                       strncpy(VUQNAME,VSYSNAME.nodename,n-1);              
  120.                }
  121.            
  122.            if (! NOHARDCLASSES)
  123.               {
  124.               if (strlen(VFQNAME) > maxvarsize-1)
  125.              {
  126.               FatalError("The fully qualified name is longer than maxvarsize!!");
  127.              }
  128.              
  129.               strcpy(buffer,VFQNAME);
  130.              
  131.               AddClassToHeap(CanonifyName(buffer));
  132.               }
  133.                    break;
  134.  
  135.    case cfsysadm:  /* Can be redefined */
  136.                    if (!IsDefinedClass(CLASSBUFF))
  137.                       {
  138.               break;
  139.               }
  140.  
  141.                   strcpy(VSYSADM,value);
  142.                   break;
  143.  
  144.    case cfnetmask:
  145.                    if (!IsDefinedClass(CLASSBUFF))
  146.                       {
  147.               break;
  148.               }
  149.  
  150.                   if (VNETMASK[0] != '\0')
  151.                      {
  152.                      yyerror("Multiple declaration of variable netmask");
  153.                      FatalError("Redefinition of basic system variable");
  154.                      }
  155.                   strcpy(VNETMASK,value);
  156.                   break;
  157.  
  158.  
  159.    case cfmountpat: SetMountPath(value);
  160.                     break;
  161.  
  162.    case cfrepos:
  163.                    SetRepository(value);
  164.            break;
  165.  
  166.    case cfhomepat:  
  167.                   Debug1("Installing %s as home pattern\n",value);
  168.                   AppendItem(&VHOMEPATLIST,value,CLASSBUFF);
  169.                   break;
  170.  
  171.    case cfextension:
  172.                   AppendItem(&EXTENSIONLIST,value,CLASSBUFF);
  173.                   break;
  174.  
  175.    case cfsuspicious:
  176.                   AppendItem(&SUSPICIOUSLIST,value,CLASSBUFF);
  177.           break;
  178.           
  179.    case cftimezone:
  180.                    if (!IsDefinedClass(CLASSBUFF))
  181.                       {
  182.               break;
  183.               }
  184.  
  185.                     AppendItem(&VTIMEZONE,value,NULL);
  186.                     break;
  187.  
  188.    case cfssize: 
  189.                   sscanf(value,"%d",&number);
  190.                   if (number >= 0)
  191.                      {
  192.                      SENSIBLEFSSIZE = number;
  193.                      }
  194.                   else
  195.                      {
  196.                      yyerror("Silly value for sensiblesize (must be positive integer)");
  197.                      }
  198.                   break;
  199.  
  200.    case cfscount:
  201.                   sscanf(value,"%d",&number);
  202.                   if (number > 0)
  203.                      {
  204.                      SENSIBLEFILECOUNT = number;
  205.                      }
  206.                   else
  207.                      {
  208.                      yyerror("Silly value for sensiblecount (must be positive integer)");
  209.                      }
  210.  
  211.                   break;
  212.  
  213.    case cfeditsize:
  214.                   sscanf(value,"%d",&number);
  215.  
  216.                   if (number >= 0)
  217.                      {
  218.                      EDITFILESIZE = number;
  219.                      }
  220.                   else
  221.                      {
  222.                      yyerror("Silly value for editfilesize (must be positive integer)");
  223.                      }
  224.  
  225.                   break;
  226.  
  227.  
  228.    case cfifelapsed:
  229.                   sscanf(value,"%d",&number);
  230.  
  231.                   if (number >= 0)
  232.                      {
  233.                      VDEFAULTIFELAPSED = VIFELAPSED = number;
  234.                      }
  235.                   else
  236.                      {
  237.                      yyerror("Silly value for IfElapsed");
  238.                      }
  239.  
  240.                   break;
  241.           
  242.    case cfexpireafter:
  243.                   sscanf(value,"%d",&number);
  244.  
  245.                   if (number > 0)
  246.                      {
  247.                      VDEFAULTEXPIREAFTER = VEXPIREAFTER = number;
  248.                      }
  249.                   else
  250.                      {
  251.                      yyerror("Silly value for ExpireAfter");
  252.                      }
  253.  
  254.                   break;
  255.           
  256.  
  257.    case cfactseq:
  258.                   AppendToActionSequence(value);
  259.                   break;
  260.  
  261.    case cfaccess:
  262.                   AppendToAccessList(value);
  263.                   break;
  264.  
  265.    case cfnfstype:
  266.                   strcpy(VNFSTYPE,value); 
  267.                   break;
  268.  
  269.    case cfaddclass:
  270.                   AddCompoundClass(value);
  271.                   break;
  272.  
  273.    case cfinstallclass:
  274.                   AddInstallable(value);
  275.           break;
  276.           
  277.    case cfexcludecp:
  278.                   PrependItem(&VEXCLUDECOPY,value,CLASSBUFF);
  279.                   break;
  280.           
  281.    case cfexcludeln:
  282.                   PrependItem(&VEXCLUDELINK,value,CLASSBUFF);
  283.                   break;
  284.           
  285.    case cfcplinks:
  286.                   PrependItem(&VCOPYLINKS,value,CLASSBUFF);
  287.                   break;
  288.    case cflncopies:
  289.                   PrependItem(&VLINKCOPIES,value,CLASSBUFF);
  290.                   break;
  291.  
  292.    case cfrepchar:
  293.             if (strlen(value) > 1)
  294.             {
  295.             yyerror("reposchar can only be a single letter");
  296.             break;
  297.             }
  298.              if (value[0] == '/')
  299.             {
  300.             yyerror("illegal value for reposchar");
  301.             break;
  302.             }
  303.              REPOSCHAR = value[0];
  304.              break;
  305.  
  306.    case cflistsep:
  307.             if (strlen(value) > 1)
  308.                {
  309.                yyerror("listseparator can only be a single letter");
  310.                break;
  311.                }
  312.             if (value[0] == '/')
  313.                {
  314.                yyerror("illegal value for listseparator");
  315.                break;
  316.                }
  317.             LISTSEPARATOR = value[0];
  318.             break;
  319.             
  320.    case cfunderscore:
  321.                         if (strcmp(value,"on") == 0)
  322.                { char rename[maxvarsize];
  323.                UNDERSCORE_CLASSES=true;
  324.                Verbose("Resetting classes using underscores...\n");
  325.                while(DeleteItemContaining(&VHEAP,CLASSTEXT[VSYSTEMHARDCLASS]))
  326.                   {
  327.                   }
  328.  
  329.                sprintf(rename,"_%s",CLASSTEXT[VSYSTEMHARDCLASS]);
  330.                
  331.                            AddClassToHeap(rename);
  332.                break;
  333.                }
  334.  
  335.             if (strcmp(value,"off") == 0)
  336.                {
  337.                UNDERSCORE_CLASSES=false;
  338.                break;
  339.                }
  340.             
  341.                         yyerror("illegal value for underscoreclasses");
  342.             break;
  343.  
  344.    case cfifname:    if (strlen(value)>15)
  345.                         {
  346.                      yyerror("Silly interface name, (should be something link eth0)");
  347.                     }
  348.  
  349.                      strcpy(VIFNAMEOVERRIDE,value);
  350.              VIFDEV[VSYSTEMHARDCLASS] = VIFNAMEOVERRIDE; /* override */
  351.              Debug("Overriding interface with %s\n",VIFDEV[VSYSTEMHARDCLASS]);
  352.              break;
  353.  
  354.    case cfdefcopy: if (strcmp(value,"ctime") == 0)
  355.                       {
  356.               DEFAULTCOPYTYPE = 't';
  357.               return;
  358.               }
  359.                    else if (strcmp(value,"mtime") == 0)
  360.               {
  361.               DEFAULTCOPYTYPE = 'm';
  362.               return;
  363.               }
  364.                    else if (strcmp(value,"checksum")==0 || strcmp(value,"sum") == 0)
  365.               {
  366.               DEFAULTCOPYTYPE = 'c';
  367.               return;
  368.               }
  369.                    else if (strcmp(value,"byte")==0 || strcmp(value,"binary") == 0)
  370.               {
  371.               DEFAULTCOPYTYPE = 'b';
  372.               return;
  373.               }
  374.                    yyerror("Illegal default copy type");
  375.            break;
  376.  
  377.    default:       AddMacroValue(CURRENTITEM,value);
  378.                   break;
  379.    }
  380. }
  381.  
  382. /*******************************************************************/
  383.  
  384. HandleEdit(file,edit,string)      /* child routines in edittools.c */
  385.  
  386. char *file, *edit, *string;
  387.  
  388. {
  389. if (string == NULL)
  390.    {
  391.    Debug1("Handling Edit of %s, action [%s] with no data\n",file,edit);
  392.    }
  393. else
  394.    {
  395.    Debug1("Handling Edit of %s, action [%s] with data <%s>\n",file,edit,string);
  396.    }
  397.  
  398. if (EditFileExists(file))
  399.    {
  400.    AddEditAction(file,edit,string);
  401.    }
  402. else
  403.    {
  404.    InstallEditFile(file,edit,string);
  405.    }
  406. }
  407.  
  408. /********************************************************************/
  409.  
  410. HandleOptionalFileAttribute(item)
  411.  
  412. char *item;
  413.  
  414. { char value[maxvarsize];
  415.  
  416. VBUFF[0] = value[0] = '\0';
  417.  
  418. ExpandVarstring(item,VBUFF,NULL);
  419.  
  420. sscanf(VBUFF,"%*[^=]=%s",value);
  421.  
  422. if (value[0] == '\0')
  423.    {
  424.    yyerror("File attribute with no value");
  425.    }
  426.  
  427. Debug1("HandleOptionalFileAttribute(%s)\n",value);
  428.  
  429. switch(GetCommAttribute(item))
  430.    {
  431.    case cfrecurse: HandleRecurse(value);
  432.                    break;
  433.    case cfmode:    ParseModeString(value,&PLUSMASK,&MINUSMASK);
  434.                    break;
  435.    case cfflags:   ParseFlagString(value,&PLUSFLAG,&MINUSFLAG);
  436.                    break;           
  437.    case cfowner:   strcpy(VUIDNAME,value);
  438.                    break;
  439.    case cfgroup:   strcpy(VGIDNAME,value);
  440.                    break;
  441.    case cfaction:  FILEACTION = (enum fileactions) GetFileAction(value);
  442.                    break;
  443.    case cflinks:   HandleTravLinks(value);
  444.                    break;
  445.    case cfexclude: PrependItem(&VEXCLUDEPARSE,value,"any");
  446.                    break;
  447.    case cfinclude: PrependItem(&VINCLUDEPARSE,value,"any");
  448.                    break;
  449.    case cfignore:  PrependItem(&VIGNOREPARSE,value,"any");
  450.                    break;
  451.    case cfacl:     PrependItem(&VACLBUILD,value,"any");
  452.                    break;
  453.    case cfdefine:  HandleDefine(value);
  454.                    break;
  455.    case cfsetlog:  HandleSetLog(value);
  456.                    break;
  457.    case cfsetinform: HandleSetInform(value);
  458.                    break;
  459.  
  460.    case cfchksum:  HandleChecksum(value);
  461.                    break;
  462.    default:        yyerror("Illegal file attribute");
  463.    }
  464. }
  465.  
  466.  
  467. /*******************************************************************/
  468.  
  469. HandleOptionalImageAttribute(item)
  470.  
  471. char *item;
  472.  
  473. { char value[bufsize];
  474.  
  475. VBUFF[0] = value[0] = '\0';
  476.  
  477. ExpandVarstring(item,VBUFF,NULL);
  478.  
  479. sscanf(VBUFF,"%*[^=]=%s",value);
  480.  
  481. if (value[0] == '\0')
  482.    {
  483.    yyerror("Copy attribute with no value");
  484.    }
  485.  
  486. Debug1("HandleOptionalImageAttribute(%s)\n",value);
  487.  
  488. switch(GetCommAttribute(item))
  489.    {
  490.    case cfmode:    ParseModeString(value,&PLUSMASK,&MINUSMASK);
  491.                    break;
  492.    case cfflags:   ParseFlagString(value,&PLUSFLAG,&MINUSFLAG);
  493.                    break;
  494.    case cfowner:   strcpy(VUIDNAME,value);
  495.                    break;
  496.    case cfgroup:   strcpy(VGIDNAME,value);
  497.                    break;
  498.    case cfdest:    strcpy(DESTINATION,value);
  499.                    break;
  500.    case cfaction:  strcpy(IMAGEACTION,value);
  501.                    break;
  502.    case cfforce:   HandleForceCopy(value);
  503.                    break;
  504.    case cfbackup:  HandleCopyBackup(value);
  505.                    break;
  506.    case cfrecurse: HandleRecurse(value);
  507.                    break;
  508.    case cftype:    HandleCopyType(value);
  509.                    break;
  510.    case cfexclude: PrependItem(&VEXCLUDEPARSE,value,"any");
  511.                    break;
  512.    case cfsymlink: PrependItem(&VCPLNPARSE,value,"any");
  513.                    break;
  514.    case cfinclude: PrependItem(&VINCLUDEPARSE,value,"any");
  515.                    break;
  516.    case cfignore:  PrependItem(&VIGNOREPARSE,value,"any");
  517.                    break;
  518.    case cflntype:  HandleLinkType(value);
  519.                    break;
  520.    case cfserver:  HandleServer(value);
  521.                    break;
  522.    case cfsecure:  HandleSetSecure(value);
  523.                    break;
  524.    case cfdefine:  HandleDefine(value);
  525.                    break;
  526.    case cfsize:    HandleCopySize(value);
  527.                    break;
  528.    case cfacl:     PrependItem(&VACLBUILD,value,"any");
  529.                    break;
  530.    case cfpurge:   HandlePurge(value);
  531.                    break;
  532.    case cfsetlog:  HandleSetLog(value);
  533.                    break;
  534.    case cfsetinform: HandleSetInform(value);
  535.                    break;
  536.    case cfstealth: HandleStealth(value);
  537.                    break;
  538.  
  539.    default:        yyerror("Illegal copy attribute");
  540.    }
  541. }
  542.  
  543. /******************************************************************/
  544.  
  545. HandleOptionalRequired(item)
  546.  
  547. char *item;
  548.  
  549. { char value[maxvarsize];
  550.  
  551. VBUFF[0] = value[0] = '\0';
  552.  
  553. ExpandVarstring(item,VBUFF,NULL);
  554.  
  555. sscanf(VBUFF,"%*[^=]=%s",value);
  556.  
  557. if (value[0] == '\0')
  558.    {
  559.    yyerror("Required/disk attribute with no value");
  560.    }
  561.  
  562. Debug1("HandleOptionalRequiredAttribute(%s)\n",value);
  563.  
  564. switch(GetCommAttribute(item))
  565.    {
  566.    case cffree:    HandleRequiredSize(value);
  567.                    break;
  568.    case cfdefine:  HandleDefine(value);
  569.                    break;
  570.    case cfsetlog:  HandleSetLog(value);
  571.                    break;
  572.    case cfsetinform: HandleSetInform(value);
  573.                    break;
  574.  
  575.    default:        yyerror("Illegal disk/required attribute");
  576.    }
  577.  
  578. }
  579.  
  580. /******************************************************************/
  581.  
  582. HandleOptionalInterface(item)
  583.  
  584. char *item;
  585.  
  586. { char value[maxvarsize];
  587.  
  588. VBUFF[0] = value[0] = '\0';
  589.  
  590. ExpandVarstring(item,VBUFF,NULL);
  591.  
  592. sscanf(VBUFF,"%*[^=]=%s",value);
  593.  
  594. if (value[0] == '\0')
  595.    {
  596.    yyerror("intefaces attribute with no value");
  597.    }
  598.  
  599. Debug1("HandleOptionalRequiredAttribute(%s)\n",value);
  600.  
  601. switch(GetCommAttribute(item))
  602.    {
  603.    case cfsetnetmask:   HandleNetmask(value);
  604.                         break;
  605.    case cfsetbroadcast: HandleBroadcast(value);
  606.                         break;
  607.  
  608.    default:        yyerror("Illegal interfaces attribute");
  609.    }
  610.  
  611. }
  612.  
  613.  
  614. /******************************************************************/
  615.  
  616. HandleOptionalUnMountAttribute(item)
  617.  
  618. char *item;
  619.  
  620. { char value[maxvarsize];
  621.  
  622. VBUFF[0] = value[0] = '\0';
  623.  
  624. ExpandVarstring(item,VBUFF,NULL);
  625.  
  626. sscanf(VBUFF,"%*[^=]=%s",value);
  627.  
  628. if (value[0] == '\0')
  629.    {
  630.    yyerror("Unmount attribute with no value");
  631.    }
  632.  
  633. Debug1("HandleOptionalUnMountsItem(%s)\n",value);
  634.  
  635. switch(GetCommAttribute(item))
  636.    {
  637.    case cfdeldir: if (strcmp(value,"true") == 0 || strcmp(value,"yes") == 0)
  638.                      {
  639.              DELETEDIR = 't';
  640.              break;
  641.              }
  642.    
  643.                   if (strcmp(value,"false") == 0 || strcmp(value,"no") == 0)
  644.                      {
  645.              DELETEDIR = 'f';
  646.              break;
  647.              }
  648.  
  649.    case cfdelfstab: if (strcmp(value,"true") == 0 || strcmp(value,"yes") == 0)
  650.                        {
  651.                DELETEFSTAB = 't';
  652.                break;
  653.                }
  654.    
  655.                     if (strcmp(value,"false") == 0 || strcmp(value,"no") == 0)
  656.                        {
  657.                DELETEDIR = 'f';
  658.                break;
  659.                }   
  660.             
  661.    case cfforce:    if (strcmp(value,"true") == 0 || strcmp(value,"yes") == 0)
  662.                        {
  663.                FORCE = 't';
  664.                break;
  665.                }
  666.    
  667.                     if (strcmp(value,"false") == 0 || strcmp(value,"no") == 0)
  668.                        {
  669.                FORCE = 'f';
  670.                break;
  671.                }
  672.  
  673.    default:         yyerror("Illegal unmount attribute (rw/ro)");
  674.    }
  675.  
  676. }
  677.  
  678. /******************************************************************/
  679.  
  680. HandleOptionalMiscMountsAttribute(item)
  681.  
  682. char *item;
  683.  
  684. { char value[maxvarsize];
  685.  
  686. VBUFF[0] = value[0] = '\0';
  687.  
  688. ExpandVarstring(item,VBUFF,NULL);
  689.  
  690. sscanf(VBUFF,"%*[^=]=%s",value);
  691.  
  692. if (value[0] == '\0')
  693.    {
  694.    yyerror("Miscmounts attribute with no value");
  695.    }
  696.  
  697. Debug1("HandleOptionalMiscMOuntsItem(%s)\n",value);
  698.  
  699. switch(GetCommAttribute(item))
  700.    {
  701.    case cfmode:    if (strcmp(value,"rw") == 0)
  702.                       {
  703.               MOUNTMODE='w';
  704.               break;
  705.                       }
  706.    
  707.                    if (strcmp(value,"ro") == 0)
  708.                       {
  709.               MOUNTMODE='o';
  710.               break;
  711.                       }
  712.    
  713.    default:        yyerror("Illegal miscmounts attribute (rw/ro)");
  714.    }
  715.  
  716. }
  717.  
  718. /******************************************************************/
  719.  
  720. HandleOptionalTidyAttribute(item)
  721.  
  722. char *item;
  723.  
  724. { char value[maxvarsize];
  725.  
  726. VBUFF[0] = value[0] = '\0';
  727.  
  728. ExpandVarstring(item,VBUFF,NULL);
  729.  
  730. sscanf(VBUFF,"%*[^=]=%s",value);
  731.  
  732. if (value[0] == '\0')
  733.    {
  734.    yyerror("Tidy attribute with no value");
  735.    }
  736.  
  737. Debug1("HandleOptionalTidyAttribute(%s)\n",value);
  738.  
  739. switch(GetCommAttribute(item))
  740.    {
  741.    case cfrecurse: HandleRecurse(value);
  742.                    break;
  743.  
  744.    case cfpattern: strcpy(CURRENTITEM,value);
  745.                    if (*value == '/')
  746.               {
  747.               yyerror("search pattern begins with / must be a relative name");
  748.               }
  749.                    break;
  750.  
  751.    case cfage:     HandleAge(value);
  752.                    break;
  753.  
  754.    case cflinks:   HandleTravLinks(value);
  755.                    break;
  756.  
  757.    case cfsize:    HandleTidySize(value);
  758.                    break;
  759.  
  760.    case cftype:    HandleTidyType(value);
  761.                    break;
  762.  
  763.    case cfdirlinks:
  764.                    HandleTidyLinkDirs(value);
  765.            break;
  766.  
  767.    case cfrmdirs:  HandleTidyRmdirs(value);
  768.                    break;
  769.  
  770.    case cfdefine:  HandleDefine(value);
  771.                    break;
  772.    case cfsetlog:  HandleSetLog(value);
  773.                    break;
  774.    case cfsetinform: HandleSetInform(value);
  775.                    break;
  776.  
  777.    default:        yyerror("Illegal tidy attribute");
  778.    }
  779. }
  780.  
  781. /******************************************************************/
  782.  
  783. HandleOptionalDirAttribute(item)
  784.  
  785. char *item;
  786.  
  787. { char value[maxvarsize];
  788.  
  789. VBUFF[0] = value[0] = '\0';
  790.  
  791. ExpandVarstring(item,VBUFF,NULL);
  792.  
  793. sscanf(item,"%*[^=]=%s",value);
  794.  
  795. if (value[0] == '\0')
  796.    {
  797.    yyerror("Directory attribute with no value");
  798.    }
  799.  
  800. Debug1("HandleOptionalDirAttribute(%s)\n",value);
  801.  
  802. switch(GetCommAttribute(item))
  803.    {
  804.    case cfmode:    ParseModeString(value,&PLUSMASK,&MINUSMASK);
  805.                    break;
  806.    case cfflags:   ParseFlagString(value,&PLUSFLAG,&MINUSFLAG);
  807.                    break;
  808.    case cfowner:   strcpy(VUIDNAME,value);
  809.                    break;
  810.    case cfgroup:   strcpy(VGIDNAME,value);
  811.                    break;
  812.    case cfdefine:  HandleDefine(value);
  813.                    break;
  814.    case cfsetlog:  HandleSetLog(value);
  815.                    break;
  816.    case cfsetinform: HandleSetInform(value);
  817.                    break;
  818.  
  819.    default:        yyerror("Illegal directory attribute");
  820.    }
  821. }
  822.  
  823.  
  824. /*******************************************************************/
  825.  
  826. HandleOptionalDisableAttribute(item)
  827.  
  828. char *item;
  829.  
  830. { char value[maxvarsize];
  831.  
  832. VBUFF[0] = value[0] = '\0';
  833.  
  834. ExpandVarstring(item,VBUFF,NULL);
  835.  
  836. sscanf(VBUFF,"%*[^=]=%s",value);
  837.  
  838. if (value[0] == '\0')
  839.    {
  840.    yyerror("Disable attribute with no value");
  841.    }
  842.  
  843. Debug1("HandleOptionalDisableAttribute(%s)\n",value);
  844.  
  845. switch(GetCommAttribute(item))
  846.    {
  847.    case cftype:    HandleDisableFileType(value);
  848.                    break;
  849.  
  850.    case cfrotate:  HandleDisableRotate(value);
  851.                    break;
  852.            
  853.    case cfsize:    HandleDisableSize(value);
  854.                    break;
  855.    case cfdefine:  HandleDefine(value);
  856.                    break;
  857.    case cfsetlog:  HandleSetLog(value);
  858.                    break;
  859.    case cfsetinform: HandleSetInform(value);
  860.                    break;
  861.  
  862.    default:        yyerror("Illegal disable attribute");
  863.    }
  864. }
  865.  
  866.  
  867. /*******************************************************************/
  868.  
  869. HandleOptionalLinkAttribute(item)
  870.  
  871. char *item;
  872.  
  873. { char value[maxvarsize];
  874.  
  875. VBUFF[0] = value[0] = '\0';
  876.  
  877. ExpandVarstring(item,VBUFF,NULL);
  878.  
  879. sscanf(VBUFF,"%*[^=]=%s",value);
  880.  
  881. if (value[0] == '\0')
  882.    {
  883.    yyerror("Link attribute with no value");
  884.    }
  885.  
  886. Debug1("HandleOptionalLinkAttribute(%s)\n",value);
  887.  
  888. switch(GetCommAttribute(item))
  889.    {
  890.    case cfaction:  HandleLinkAction(value);
  891.                    break;
  892.    case cftype:    HandleLinkType(value);
  893.                    break;
  894.    case cfexclude: PrependItem(&VEXCLUDEPARSE,value,"any");
  895.                    break;
  896.    case cfinclude: PrependItem(&VINCLUDEPARSE,value,"any");
  897.                    break;
  898.    case cfignore:  PrependItem(&VIGNOREPARSE,value,"any");
  899.                    break;
  900.    case cfcopy:    PrependItem(&VCPLNPARSE,value,"any");
  901.                    break;
  902.    case cfrecurse: HandleRecurse(value);
  903.                    break;
  904.    case cfcptype:  HandleCopyType(value);
  905.                    break;
  906.    case cfnofile:  HandleDeadLinks(value);
  907.                    break;
  908.    case cfdefine:  HandleDefine(value);
  909.                    break;
  910.    case cfsetlog:  HandleSetLog(value);
  911.                    break;
  912.    case cfsetinform: HandleSetInform(value);
  913.                    break;
  914.  
  915.    default:        yyerror("Illegal link attribute");
  916.    }
  917. }
  918.  
  919. /*******************************************************************/
  920.  
  921. HandleOptionalProcessAttribute(item)
  922.  
  923. char *item;
  924.  
  925. { char value[maxvarsize];
  926.  
  927. if (HAVE_RESTART)     /* wrote `restart' without following by ".." */
  928.    {
  929.    yyerror("Missing restart command (quoted string expected) or bad SetOptionString placement");
  930.    }
  931.  
  932. VBUFF[0] = value[0] = '\0';
  933.  
  934. ExpandVarstring(item,VBUFF,NULL);
  935.  
  936. sscanf(VBUFF,"%*[^=]=%s",value);
  937.  
  938. if (value[0] == '\0')
  939.    {
  940.    yyerror("Process attribute with no value");
  941.    }
  942.  
  943. Debug1("HandleOptionalProcessAttribute(%s)\n",value);
  944.  
  945. switch(GetCommAttribute(item))
  946.    {
  947.    case cfaction:  if (strcmp(value,"signal") == 0 || strcmp(value,"do") == 0)
  948.                       {
  949.               PROACTION = 's';
  950.                       }
  951.                    else if (strcmp(value,"warn") == 0)
  952.               {
  953.               PROACTION = 'w';
  954.               }
  955.                    else
  956.               {
  957.               yyerror("Unknown action for processes");
  958.               }
  959.                    break;
  960.    case cfmatches: HandleProcessMatches(value);
  961.                    break;
  962.    case cfsignal:  HandleProcessSignal(value);
  963.                    break;
  964.    case cfdefine:  HandleDefine(value);
  965.                    break;
  966.    case cfuseshell:HandleUseShell(value);
  967.                    break;
  968.    case cfsetlog:  HandleSetLog(value);
  969.                    break;
  970.    case cfsetinform: HandleSetInform(value);
  971.                    break;
  972.    case cfexclude: PrependItem(&VEXCLUDEPARSE,value,"any");
  973.                    break;
  974.    case cfinclude: PrependItem(&VINCLUDEPARSE,value,"any");
  975.                    break;
  976.            
  977.    default:        yyerror("Illegal process attribute");
  978.    }
  979. }
  980.  
  981. /*******************************************************************/
  982.  
  983. HandleOptionalScriptAttribute(item)
  984.  
  985. char *item;
  986.  
  987. { char value[maxvarsize];
  988.  
  989. VBUFF[0] = value[0] = '\0';
  990.  
  991. ExpandVarstring(item,VBUFF,NULL);
  992.  
  993. sscanf(VBUFF,"%*[^=]=%s",value);
  994.  
  995. if (value[0] == '\0')
  996.    {
  997.    yyerror("Shellcommand attribute with no value");
  998.    }
  999.  
  1000. Debug1("HandleOptionalLinkAttribute(%s)\n",value);
  1001.  
  1002. switch(GetCommAttribute(item))
  1003.    {
  1004.    case cftimeout:   HandleTimeOut(value);
  1005.                      break;
  1006.    case cfuseshell:  HandleUseShell(value);
  1007.                      break;
  1008.    case cfsetlog:    HandleSetLog(value);
  1009.                      break;
  1010.    case cfsetinform: HandleSetInform(value);
  1011.                      break;
  1012.    case cfowner:     strcpy(VUIDNAME,value);
  1013.              break;
  1014.    case cfgroup:     strcpy(VGIDNAME,value);
  1015.                      break;
  1016.    case cfdefine:    HandleDefine(value);
  1017.                      break;
  1018.  
  1019.    default:         yyerror("Illegal shellcommand attribute");
  1020.    }
  1021.  
  1022. }
  1023.  
  1024. /*******************************************************************/
  1025.  
  1026. HandleFileItem(item)
  1027.  
  1028. char *item;
  1029.  
  1030. { char err[100];
  1031.  
  1032. if (strcmp(item,"home") == 0)
  1033.    {
  1034.    ACTIONPENDING=true;
  1035.    strcpy(CURRENTPATH,"home");
  1036.    return;
  1037.    }
  1038.  
  1039. sprintf(err,"Unknown attribute %s",item);
  1040. yyerror(err);
  1041. }
  1042.  
  1043.  
  1044. /*******************************************************************/
  1045.  
  1046. InstallBroadcastItem(item)
  1047.  
  1048. char *item;
  1049.  
  1050. {
  1051. Debug1("Install broadcast mode (%s)\n",item);
  1052.  
  1053. if ( ! IsInstallable(CLASSBUFF))
  1054.    {
  1055.    Debug1("Not installing %s, no match\n",item);
  1056.    return;
  1057.    }
  1058.  
  1059. if (VBROADCAST[0] != '\0')
  1060.    {
  1061.    yyerror("Multiple declaration of variable broadcast");
  1062.    FatalError("Redefinition of basic system variable");
  1063.    }
  1064.  
  1065. if (strcmp("ones",item) == 0)
  1066.    {
  1067.    strcpy(VBROADCAST,"one");
  1068.    return;
  1069.    }
  1070.  
  1071. if (strcmp("zeroes",item) == 0)
  1072.    {
  1073.    strcpy(VBROADCAST,"zero");
  1074.    return;
  1075.    }
  1076.  
  1077. if (strcmp("zeros",item) == 0)
  1078.    {
  1079.    strcpy(VBROADCAST,"zero");
  1080.    return;
  1081.    }
  1082.  
  1083. yyerror ("Unknown broadcast mode (should be ones, zeros or zeroes)");
  1084. FatalError("Unknown broadcast mode");
  1085. }
  1086.  
  1087. /*******************************************************************/
  1088.  
  1089. InstallDefaultRouteItem(item)
  1090.  
  1091. char *item;
  1092.  
  1093. { struct hostent *hp;
  1094.   struct in_addr inaddr;
  1095.  
  1096. Debug1("Install defaultroute mode (%s)\n",item);
  1097.  
  1098. if (!IsDefinedClass(CLASSBUFF))
  1099.    {
  1100.    Debug1("Not installing %s, no match\n",item);
  1101.    return;
  1102.    }
  1103.  
  1104. if (VDEFAULTROUTE[0] != '\0')
  1105.    {
  1106.    yyerror("Multiple declaration of variable defaultroute");
  1107.    FatalError("Redefinition of basic system variable");
  1108.    }
  1109.  
  1110. ExpandVarstring(item,VBUFF,NULL);
  1111.  
  1112.  if (inet_addr(VBUFF) == -1)
  1113.    {
  1114.    if ((hp = gethostbyname(VBUFF)) == NULL)
  1115.       {
  1116.       sprintf(OUTPUT,"Bad address/host (%s) in default route\n",VBUFF);
  1117.       CfLog(cferror,OUTPUT,"gethostbyname");
  1118.       yyerror ("Bad specification of default packet route: hostname or decimal IP address");
  1119.       }
  1120.    else
  1121.       {
  1122.       bcopy(hp->h_addr,&inaddr, hp->h_length);
  1123.       strcpy(VDEFAULTROUTE,inet_ntoa(inaddr));
  1124.       }
  1125.    }
  1126. else
  1127.    {
  1128.    strcpy(VDEFAULTROUTE,VBUFF);
  1129.    }
  1130. }
  1131.  
  1132. /*******************************************************************/
  1133.  
  1134. HandleGroupItem(item,type)
  1135.  
  1136. char *item;
  1137. enum itemtypes type;
  1138.  
  1139. { char *machine, *user, *domain;
  1140.  
  1141. Debug1("Handling item (%s) in group (%s), type=%d\n",item,GROUPBUFF,type);
  1142.  
  1143. switch (type)
  1144.    {
  1145.    case simple:    if (strcmp(item,VDEFAULTBINSERVER.name) == 0)
  1146.                       {
  1147.                       AddClassToHeap(GROUPBUFF);
  1148.                       break;
  1149.                       }
  1150.  
  1151.                    if (strcmp(item,VFQNAME) == 0)
  1152.                       {
  1153.                       AddClassToHeap(GROUPBUFF);
  1154.                       break;
  1155.                       }
  1156.  
  1157.                    if (IsItemIn(VHEAP,item))  /* group reference */
  1158.                       {
  1159.                       AddClassToHeap(GROUPBUFF);
  1160.                       break;
  1161.                       }
  1162.  
  1163.                    break;
  1164.  
  1165.    case netgroup:  setnetgrent(item);
  1166.  
  1167.                    while (getnetgrent(&machine,&user,&domain))
  1168.                       {
  1169.                       if (strcmp(machine,VDEFAULTBINSERVER.name) == 0)
  1170.                          {
  1171.                          Debug1("Matched %s in netgroup %s\n",machine,item);
  1172.                          AddClassToHeap(GROUPBUFF);
  1173.                          break;
  1174.                          }
  1175.  
  1176.               if (strcmp(machine,VFQNAME) == 0)
  1177.                          {
  1178.                          Debug1("Matched %s in netgroup %s\n",machine,item);
  1179.                          AddClassToHeap(GROUPBUFF);
  1180.                          break;
  1181.                          }
  1182.                       }
  1183.                    
  1184.                    endnetgrent();
  1185.                    break;
  1186.  
  1187.  
  1188.    case groupdeletion: 
  1189.  
  1190.                    setnetgrent(item);
  1191.  
  1192.                    while (getnetgrent(&machine,&user,&domain))
  1193.                       {
  1194.                       if (strcmp(machine,VDEFAULTBINSERVER.name) == 0)
  1195.                          {
  1196.                          Debug1("Matched delete item %s in netgroup %s\n",machine,item);
  1197.                          DeleteItemStarting(&VHEAP,GROUPBUFF);
  1198.                          break;
  1199.                          }
  1200.               
  1201.                       if (strcmp(machine,VFQNAME) == 0)
  1202.                          {
  1203.                          Debug1("Matched delete item %s in netgroup %s\n",machine,item);
  1204.                          DeleteItemStarting(&VHEAP,GROUPBUFF);
  1205.                          break;
  1206.                          }
  1207.               
  1208.                       }
  1209.                    
  1210.                    endnetgrent();
  1211.                    break;
  1212.  
  1213.    case classscript:
  1214.  
  1215.                    VBUFF[0] = '\0';
  1216.                    ExpandVarstring (item+1,VBUFF,NULL);
  1217.                    if (VBUFF[0] != '/')
  1218.                       {
  1219.                       yyerror("Quoted scripts must begin with / for absolute path");
  1220.                       break;
  1221.                       }
  1222.  
  1223.                    if (ShellCommandReturnsZero(VBUFF))
  1224.                       {
  1225.                       AddClassToHeap(GROUPBUFF);
  1226.                       }
  1227.  
  1228.                    break;
  1229.  
  1230.    case deletion:  if (IsDefinedClass(item))
  1231.                       {
  1232.                       DeleteItemStarting(&VHEAP,GROUPBUFF);
  1233.                       }
  1234.                    break;
  1235.  
  1236.    default:        yyerror("Software error");
  1237.                    FatalError("Unknown item type");
  1238.    }
  1239. }
  1240.  
  1241. /*******************************************************************/
  1242.  
  1243. HandleHomePattern(pattern)
  1244.  
  1245. char *pattern;
  1246.  
  1247. {
  1248. VBUFF[0]='\0';
  1249. ExpandVarstring(pattern,VBUFF,"");
  1250. AppendItem(&VHOMEPATLIST,VBUFF,CLASSBUFF);
  1251. }
  1252.  
  1253. /*******************************************************************/
  1254.  
  1255. AppendNameServer(item)
  1256.  
  1257. char *item;
  1258.  
  1259. { 
  1260. Debug1("Installing item (%s) in the nameserver list\n",item);
  1261.  
  1262. if ( ! IsInstallable(CLASSBUFF))
  1263.    {
  1264.    Debug1("Not installing %s, no match\n",item);
  1265.    return;
  1266.    }
  1267.  
  1268. AppendItem(&VRESOLVE,item,CLASSBUFF);
  1269. }
  1270.  
  1271. /*******************************************************************/
  1272.  
  1273. AppendImport(item)
  1274.  
  1275. char *item;
  1276.  
  1277. { 
  1278. if ( ! IsInstallable(CLASSBUFF))
  1279.    {
  1280.    Debug1("Not installing %s, no match\n",item);
  1281.    return;
  1282.    }
  1283.  
  1284. if (strcmp(item,VCURRENTFILE) == 0)
  1285.    {
  1286.    yyerror("A file cannot import itself");
  1287.    FatalError("Infinite self-reference in class inheritance");
  1288.    }
  1289.  
  1290. Debug1(">>Installing item (%s) in the import list\n",item);
  1291.  
  1292. ExpandVarstring(item,VBUFF,"");
  1293.  
  1294. AppendItem(&VIMPORT,VBUFF,CLASSBUFF);
  1295. }
  1296.  
  1297.  
  1298. /*******************************************************************/
  1299.  
  1300. InstallHomeserverItem(item)
  1301.  
  1302. char *item;
  1303.  
  1304. {
  1305. if ( ! IsInstallable(CLASSBUFF))
  1306.    {
  1307.    Debug1("Not installing %s, no match\n",item);
  1308.    return;
  1309.    }
  1310.  
  1311. Debug1("Installing item (%s) in  list for homeservers (%s) in group (%s)\n",item,CLASSBUFF,GROUPBUFF);
  1312.  
  1313. AppendItem(&VHOMESERVERS,item,CLASSBUFF);
  1314. }
  1315.  
  1316. /*******************************************************************/
  1317.  
  1318. InstallBinserverItem(item)           /* Install if matches classes */
  1319.  
  1320. char *item;
  1321.  
  1322. {
  1323. if ( ! IsInstallable(CLASSBUFF))
  1324.    {
  1325.    Debug1("Not installing %s, no match\n",item);
  1326.    return;
  1327.    }
  1328.  
  1329. AppendItem(&VBINSERVERS,item,CLASSBUFF);
  1330. }
  1331.  
  1332. /*******************************************************************/
  1333.  
  1334. InstallMailserverPath(path)
  1335.  
  1336. char *path;
  1337.  
  1338. {
  1339. if ( ! IsInstallable(CLASSBUFF))
  1340.    {
  1341.    Debug1("Not installing %s, no match\n",path);
  1342.    return;
  1343.    }
  1344.  
  1345. if (VMAILSERVER[0] != '\0')
  1346.    {
  1347.    FatalError("Redefinition of mailserver");
  1348.    }
  1349.  
  1350. strcpy(VMAILSERVER,path);
  1351.  
  1352. Debug1("Installing mailserver (%s) for group (%s)",path,GROUPBUFF);
  1353. }
  1354.  
  1355. /*******************************************************************/
  1356.  
  1357. InstallLinkItem (from,to)
  1358.  
  1359. char *from, *to;
  1360.  
  1361. { struct Link *ptr;
  1362.   char buffer[bufsize], buffer2[bufsize];
  1363.   
  1364. Debug1("Storing Link: (From)%s->(To)%s\n",from,to);
  1365.  
  1366. if ( ! IsInstallable(CLASSBUFF))
  1367.    {
  1368.    InitializeAction();
  1369.    Debug1("Not installing link no match\n");
  1370.    return;
  1371.    }
  1372.  
  1373. bzero(VBUFF,bufsize);
  1374. ExpandVarstring(from,VBUFF,"");
  1375. if (strlen(VBUFF) > 1)
  1376.    {
  1377.    DeleteSlash(VBUFF);
  1378.    }
  1379.  
  1380. bzero(buffer,bufsize);
  1381. ExpandVarstring(to,buffer,"");
  1382.  
  1383. if (strlen(VBUFF) > 1)
  1384.    { 
  1385.    DeleteSlash(buffer);
  1386.    }
  1387.  
  1388. bzero(buffer2,bufsize);
  1389. ExpandVarstring(ALLCLASSBUFFER,buffer2,""); 
  1390.  
  1391. if ((ptr = (struct Link *)malloc(sizeof(struct Link))) == NULL)
  1392.    {
  1393.    FatalError("Memory Allocation failed for InstallListItem() #1");
  1394.    }
  1395.  
  1396. if ((ptr->from = strdup(VBUFF)) == NULL)
  1397.    {
  1398.    FatalError("Memory Allocation failed for InstallListItem() #2");
  1399.    }
  1400.  
  1401. if ((ptr->to = strdup(buffer)) == NULL)
  1402.    {
  1403.    FatalError("Memory Allocation failed for InstallListItem() #3");
  1404.    }
  1405.  
  1406. if ((ptr->classes = strdup(CLASSBUFF)) == NULL)
  1407.    {
  1408.    FatalError("Memory Allocation failed for InstallListItem() #4");
  1409.    }
  1410.  
  1411. if ((ptr->defines = strdup(buffer2)) == NULL)
  1412.    {
  1413.    FatalError("Memory Allocation failed for InstallListItem() #4a");
  1414.    }
  1415.  
  1416. AddInstallable(ptr->defines);
  1417.  
  1418. if (VLINKTOP == NULL)                 /* First element in the list */
  1419.    {
  1420.    VLINK = ptr;
  1421.    }
  1422. else
  1423.    {
  1424.    VLINKTOP->next = ptr;
  1425.    }
  1426.  
  1427. if (strlen(ptr->from) > 1)
  1428.    {
  1429.    DeleteSlash(ptr->from);
  1430.    }
  1431.  
  1432. if (strlen(ptr->to) > 1)
  1433.    {
  1434.    DeleteSlash(ptr->to);
  1435.    }
  1436.  
  1437. ptr->force = FORCELINK;
  1438. ptr->silent = LINKSILENT;
  1439. ptr->type = LINKTYPE;
  1440. ptr->copytype = COPYTYPE;
  1441. ptr->next = NULL;
  1442. ptr->copy = VCPLNPARSE;
  1443. ptr->exclusions = VEXCLUDEPARSE;
  1444. ptr->inclusions = VINCLUDEPARSE;
  1445. ptr->ignores = VIGNOREPARSE;
  1446. ptr->recurse = VRECURSE;
  1447. ptr->nofile = DEADLINKS;
  1448. ptr->log = LOGP;
  1449. ptr->inform = INFORMP;
  1450.  
  1451.  
  1452. VLINKTOP = ptr;
  1453.  
  1454. if (ptr->recurse != 0)
  1455.    {
  1456.    yyerror("Recursion can only be used with +> multiple links");
  1457.    }
  1458.  
  1459. InitializeAction();
  1460. }
  1461.  
  1462. /*******************************************************************/
  1463.  
  1464. InstallLinkChildrenItem (from,to)
  1465.  
  1466. char *from, *to;
  1467.  
  1468. { struct Link *ptr;
  1469.   char *sp, buffer[bufsize];
  1470.   struct TwoDimList *tp = NULL;
  1471.  
  1472. Debug1("Storing Linkchildren item: %s -> %s\n",from,to);
  1473.  
  1474. if ( ! IsInstallable(CLASSBUFF))
  1475.    {
  1476.    InitializeAction();
  1477.    Debug1("Not installing linkchildren no match\n");
  1478.    return;
  1479.    }
  1480.  
  1481. VBUFF[0]='\0';                                /* Expand any variables */
  1482. ExpandVarstring(from,VBUFF,"");
  1483.  
  1484. bzero(buffer,bufsize);
  1485. ExpandVarstring(ALLCLASSBUFFER,buffer,""); 
  1486.  
  1487. Build2DListFromVarstring(&tp,to,'/');
  1488.     
  1489. Set2DList(tp);
  1490.  
  1491. for (sp = Get2DListEnt(tp); sp != NULL; sp = Get2DListEnt(tp))
  1492.    {
  1493.    if ((ptr = (struct Link *)malloc(sizeof(struct Link))) == NULL)
  1494.       {
  1495.       FatalError("Memory Allocation failed for InstallListChildrenItem() #1");
  1496.       }
  1497.  
  1498.    if ((ptr->from = strdup(VBUFF)) == NULL)
  1499.       {
  1500.       FatalError("Memory Allocation failed for InstallLinkchildrenItem() #2");
  1501.       }
  1502.  
  1503.    if ((ptr->to = strdup(sp)) == NULL)
  1504.       {
  1505.       FatalError("Memory Allocation failed for InstallLinkChildrenItem() #3");
  1506.       }
  1507.  
  1508.    if ((ptr->classes = strdup(CLASSBUFF)) == NULL)
  1509.       {
  1510.       FatalError("Memory Allocation failed for InstallLinkChildrenItem() #3");
  1511.       }
  1512.  
  1513. if ((ptr->defines = strdup(buffer)) == NULL)
  1514.    {
  1515.    FatalError("Memory Allocation failed for InstallListItem() #4a");
  1516.    }
  1517.  
  1518. AddInstallable(ptr->defines);
  1519.  
  1520.  if (VCHLINKTOP == NULL)                 /* First element in the list */
  1521.       {
  1522.       VCHLINK = ptr;
  1523.       }
  1524.    else
  1525.       {
  1526.       VCHLINKTOP->next = ptr;
  1527.       }
  1528.  
  1529.    ptr->force = FORCELINK;
  1530.    ptr->silent = LINKSILENT;
  1531.    ptr->type = LINKTYPE;
  1532.    ptr->next = NULL;
  1533.    ptr->copy = VCPLNPARSE;
  1534.    ptr->exclusions = VEXCLUDEPARSE;
  1535.    ptr->inclusions = VINCLUDEPARSE;
  1536.    ptr->ignores = VIGNOREPARSE;
  1537.    ptr->recurse = VRECURSE;
  1538.    ptr->log = LOGP;
  1539.    ptr->inform = INFORMP;
  1540.  
  1541.    VCHLINKTOP = ptr;
  1542.  
  1543.    if (ptr->recurse != 0 && strcmp(ptr->to,"linkchildren") == 0)
  1544.       {
  1545.       yyerror("Sorry don't know how to recurse with linkchildren keyword");
  1546.       }
  1547.    }
  1548.  
  1549. Delete2DList(tp);
  1550.  
  1551. InitializeAction();
  1552. }
  1553.  
  1554.  
  1555. /*******************************************************************/
  1556.  
  1557. InstallRequiredPath(path,defines,freespace)
  1558.  
  1559. char *path, *defines;
  1560. int freespace;
  1561.  
  1562. { struct Disk *ptr;
  1563.   char buffer[bufsize];
  1564.  
  1565. Debug1("Installing item (%s) in the required list\n",path);
  1566.  
  1567. if ( ! IsInstallable(CLASSBUFF))
  1568.    {
  1569.    InitializeAction();
  1570.    Debug1("Not installing %s, no match\n",path);
  1571.    return;
  1572.    }
  1573.  
  1574. VBUFF[0] = '\0';
  1575. ExpandVarstring(path,VBUFF,"");
  1576.  
  1577. buffer[0] = '\0';
  1578. ExpandVarstring(defines,buffer,"");
  1579.  
  1580.  
  1581. /* AppendItem(&VREQUIRED,VBUFF,CLASSBUFF);*/
  1582.  
  1583. if ((ptr = (struct Disk *)malloc(sizeof(struct Disk))) == NULL)
  1584.    {
  1585.    FatalError("Memory Allocation failed for InstallRequired() #1");
  1586.    }
  1587.  
  1588. if ((ptr->name = strdup(VBUFF)) == NULL)
  1589.    {
  1590.    FatalError("Memory Allocation failed for InstallRequired() #2");
  1591.    }
  1592.  
  1593. if ((ptr->classes = strdup(CLASSBUFF)) == NULL)
  1594.    {
  1595.    FatalError("Memory Allocation failed for InstallRequired() #2");
  1596.    }
  1597.  
  1598. if ((ptr->define = strdup(buffer)) == NULL)
  1599.    {
  1600.    FatalError("Memory Allocation failed for Installrequied() #2");
  1601.    }
  1602.  
  1603. if (VREQUIRED == NULL)                 /* First element in the list */
  1604.    {
  1605.    VREQUIRED = ptr;
  1606.    }
  1607. else
  1608.    {
  1609.    VREQUIREDTOP->next = ptr;
  1610.    }
  1611.  
  1612. AddInstallable(ptr->define);
  1613. ptr->freespace = freespace;
  1614. ptr->next = NULL;
  1615. ptr->log = LOGP;
  1616. ptr->inform = INFORMP;
  1617.  
  1618. VREQUIREDTOP = ptr;
  1619.  
  1620. InitializeAction();
  1621. }
  1622.  
  1623. /*******************************************************************/
  1624.  
  1625. AppendMountable(path)
  1626.  
  1627. char *path;
  1628.  
  1629. {
  1630. Debug1("Adding mountable %s to list\n",path);
  1631.  
  1632. AppendItem(&VMOUNTABLES,path,CLASSBUFF);
  1633. }
  1634.  
  1635. /*******************************************************************/
  1636.  
  1637. AppendUmount(path,deldir,delfstab,force)
  1638.  
  1639. char *path;
  1640. char deldir,delfstab,force;
  1641.  
  1642. { struct UnMount *ptr;
  1643.  
  1644. if ( ! IsInstallable(CLASSBUFF))
  1645.    {
  1646.    InitializeAction();
  1647.    Debug1("Not installing %s, no match\n",path);
  1648.    return;
  1649.    }
  1650.  
  1651. VBUFF[0] = '\0';
  1652. ExpandVarstring(path,VBUFF,"");
  1653.  
  1654.  if ((ptr = (struct UnMount *)malloc(sizeof(struct UnMount))) == NULL)
  1655.    {
  1656.    FatalError("Memory Allocation failed for AppendMiscMount #1");
  1657.    }
  1658.  
  1659. if ((ptr->name = strdup(VBUFF)) == NULL)
  1660.    {
  1661.    FatalError("Memory Allocation failed for InstallRequired() #2");
  1662.    }
  1663.  
  1664. if ((ptr->classes = strdup(CLASSBUFF)) == NULL)
  1665.    {
  1666.    FatalError("Memory Allocation failed for AppendMiscMount() #5");
  1667.    }
  1668.  
  1669. if (VUNMOUNTTOP == NULL)                 /* First element in the list */
  1670.    {
  1671.    VUNMOUNT = ptr;
  1672.    }
  1673. else
  1674.    {
  1675.    VUNMOUNTTOP->next = ptr;
  1676.    }
  1677.  
  1678. ptr->next = NULL;
  1679. ptr->deletedir = deldir;  /* t/f - true false */
  1680. ptr->deletefstab = delfstab;
  1681. ptr->force = force;
  1682. VUNMOUNTTOP = ptr;
  1683. }
  1684.  
  1685. /*******************************************************************/
  1686.  
  1687. AppendMiscMount(from,onto,perm)
  1688.  
  1689. char *from, *onto, *perm;
  1690.  
  1691. { struct MiscMount *ptr;
  1692.  
  1693. Debug1("Adding misc mountable %s %s (%s) to list\n",from,onto,perm);
  1694.  
  1695. if ( ! IsInstallable(CLASSBUFF))
  1696.    {
  1697.    Debug1("Not installing %s, no match\n",from);
  1698.    return;
  1699.    }
  1700.  
  1701. if ((ptr = (struct MiscMount *)malloc(sizeof(struct MiscMount))) == NULL)
  1702.    {
  1703.    FatalError("Memory Allocation failed for AppendMiscMount #1");
  1704.    }
  1705.  
  1706. ExpandVarstring(from,VBUFF,"");
  1707.  
  1708. if ((ptr->from = strdup(VBUFF)) == NULL)
  1709.    {
  1710.    FatalError("Memory Allocation failed for AppendMiscMount() #2");
  1711.    }
  1712.  
  1713. ExpandVarstring(onto,VBUFF,"");
  1714.  
  1715. if ((ptr->onto = strdup(onto)) == NULL)
  1716.    {
  1717.    FatalError("Memory Allocation failed for AppendMiscMount() #3");
  1718.    }
  1719.  
  1720. if ((ptr->options = strdup(perm)) == NULL)
  1721.    {
  1722.    FatalError("Memory Allocation failed for AppendMiscMount() #4");
  1723.    }
  1724.  
  1725. if ((ptr->classes = strdup(CLASSBUFF)) == NULL)
  1726.    {
  1727.    FatalError("Memory Allocation failed for AppendMiscMount() #5");
  1728.    }
  1729.  
  1730. if (VMISCMOUNTTOP == NULL)                 /* First element in the list */
  1731.    {
  1732.    VMISCMOUNT = ptr;
  1733.    }
  1734. else
  1735.    {
  1736.    VMISCMOUNTTOP->next = ptr;
  1737.    }
  1738.  
  1739. ptr->next = NULL;
  1740. VMISCMOUNTTOP = ptr;
  1741. }
  1742.  
  1743.  
  1744. /*******************************************************************/
  1745.  
  1746. AppendIgnore(path)
  1747.  
  1748. char *path;
  1749.  
  1750. { struct TwoDimList *tp = NULL;
  1751.   char *sp;
  1752.  
  1753. Debug1("Installing item (%s) in the ignore list\n",path);
  1754.  
  1755. if ( ! IsInstallable(CLASSBUFF))
  1756.    {
  1757.    Debug1("Not installing %s, no match\n",path);
  1758.    return;
  1759.    }
  1760.  
  1761. Build2DListFromVarstring(&tp,path,'/');
  1762.     
  1763. Set2DList(tp);
  1764.  
  1765. for (sp = Get2DListEnt(tp); sp != NULL; sp = Get2DListEnt(tp))
  1766.    {
  1767.    AppendItem(&VIGNORE,sp,CLASSBUFF);
  1768.    }
  1769.  
  1770. Delete2DList(tp);
  1771. }
  1772.  
  1773. /*******************************************************************/
  1774.  
  1775. InstallPending(action)
  1776.  
  1777. enum actions action;
  1778.  
  1779. {
  1780. if (ACTIONPENDING)
  1781.    {
  1782.    Debug1("\n   [BEGIN InstallPending %s\n",ACTIONTEXT[action]);
  1783.    }
  1784. else
  1785.    {
  1786.    Debug1("   (No actions pending in %s)\n",ACTIONTEXT[action]);
  1787.    return;
  1788.    }
  1789.  
  1790. switch (action)
  1791.    {
  1792.    case files:
  1793.                   InstallFileListItem(CURRENTPATH,PLUSMASK,MINUSMASK,FILEACTION,VUIDNAME,
  1794.                       VGIDNAME,VRECURSE,(char)PTRAVLINKS,ALLCLASSBUFFER,CHECKSUM);
  1795.                   break;
  1796.  
  1797.    case processes: InstallProcessItem(EXPR,RESTART,PROMATCHES,PROCOMP,
  1798.                       PROSIGNAL,PROACTION,CLASSBUFF,ALLCLASSBUFFER,USESHELL);
  1799.                    break;
  1800.    case image:
  1801.                   InstallImageItem(CURRENTPATH,PLUSMASK,MINUSMASK,DESTINATION,
  1802.                    IMAGEACTION,VUIDNAME,VGIDNAME,FORCECOPY,IMGSIZE,IMGCOMP,
  1803.                    IMAGEBACKUP,VRECURSE,COPYTYPE,LINKTYPE,CFSERVER,
  1804.                    ALLCLASSBUFFER,PURGE,STEALTH,SECURE);
  1805.                   break;
  1806.  
  1807.    case tidy:     if (VAGE >= 99999)
  1808.                      {
  1809.                      yyerror("Must specify an age for tidy actions");
  1810.                      return;
  1811.                      }
  1812.                   InstallTidyItem(CURRENTPATH,CURRENTITEM,VRECURSE,VAGE,(char)PTRAVLINKS,
  1813.                   TIDYSIZE,AGETYPE,LINKDIRS,TIDYDIRS,CLASSBUFF,ALLCLASSBUFFER);
  1814.                   break;
  1815.  
  1816.    case makepath: InstallMakePath(CURRENTPATH,PLUSMASK,MINUSMASK,VUIDNAME,VGIDNAME,ALLCLASSBUFFER);
  1817.                   break;
  1818.  
  1819.    case disable:  AppendDisable(CURRENTPATH,CURRENTITEM,ROTATE,DISCOMP,DISABLESIZE,ALLCLASSBUFFER);
  1820.                   break;
  1821.  
  1822.    case shellcommands:
  1823.                   AppendScript(CURRENTPATH,VTIMEOUT,USESHELL,VUIDNAME,VGIDNAME);
  1824.           break;
  1825.  
  1826.    case interfaces:
  1827.                   AppendInterface(VIFNAME,DESTINATION,CURRENTPATH);
  1828.           break;
  1829.  
  1830.    case required:
  1831.                   InstallRequiredPath(CURRENTPATH,ALLCLASSBUFFER,IMGSIZE);
  1832.                   break;
  1833.  
  1834.    case misc_mounts:
  1835.  
  1836.                   if ((strlen(MOUNTFROM) != 0) && (strlen(MOUNTONTO) != 0))
  1837.              {
  1838.              switch (MOUNTMODE)
  1839.             {
  1840.             case 'o': AppendMiscMount(MOUNTFROM,MOUNTONTO,"ro");
  1841.                 break;
  1842.             case 'w': AppendMiscMount(MOUNTFROM,MOUNTONTO,"rw");
  1843.                 break;
  1844.             default:  printf("Install pending, miscmount, shouldn't happen\n");
  1845.             }
  1846.              }
  1847.           
  1848.           InitializeAction();
  1849.           break;
  1850.  
  1851.    case unmounta:
  1852.                   AppendUmount(CURRENTPATH,DELETEDIR,DELETEFSTAB,FORCE);
  1853.           break;
  1854.            
  1855.    case links:
  1856.  
  1857.                   if (LINKTO[0] == '\0')
  1858.                      {
  1859.                      return;
  1860.                      }
  1861.  
  1862.                   if (ACTION_IS_LINKCHILDREN)
  1863.                      {
  1864.                      InstallLinkChildrenItem(LINKFROM,LINKTO);
  1865.                      ACTION_IS_LINKCHILDREN = false;
  1866.                      }
  1867.                   else if (ACTION_IS_LINK)
  1868.                      {
  1869.                      InstallLinkItem(LINKFROM,LINKTO);
  1870.                      ACTION_IS_LINK = false;
  1871.                      }
  1872.                   else
  1873.                      {
  1874.                      return;                                   /* Don't have whole command */
  1875.                      }
  1876.  
  1877.                   break;
  1878.    }
  1879.  
  1880. LINKFROM[0] = '\0';
  1881. LINKTO[0] = '\0';
  1882. ACTIONPENDING = false;
  1883. CURRENTITEM[0] = '\0';
  1884. CURRENTITEM[0] = '\0';
  1885. VRECURSE = 0;
  1886. VAGE=99999;
  1887. Debug1("   END InstallPending]\n\n");
  1888. }
  1889.  
  1890. /*******************************************************************/
  1891. /* Level 3                                                         */
  1892. /*******************************************************************/
  1893.  
  1894. EditFileExists(file)
  1895.  
  1896. char *file;
  1897.  
  1898. { struct Edit *ptr;
  1899.  
  1900. VBUFF[0]='\0';                         /* Expand any variables */
  1901. ExpandVarstring(file,VBUFF,"");
  1902.  
  1903. for (ptr=VEDITLIST; ptr != NULL; ptr=ptr->next)
  1904.    {
  1905.    if (strcmp(ptr->fname,VBUFF) == 0)
  1906.       {
  1907.       return true;
  1908.       }
  1909.    }
  1910. return false;
  1911. }
  1912.  
  1913. /********************************************************************/
  1914.  
  1915. GetExecOutput(command,buffer)
  1916.  
  1917. /* Buffer initially contains whole exec string */
  1918.  
  1919. char *command, *buffer;
  1920.  
  1921. { int offset = 0;
  1922.   char line[bufsize], *sp; 
  1923.   FILE *pp;
  1924.  
  1925. Debug1("GetExecOutput(%s,%s)\n",command,buffer);
  1926.   
  1927. if (DONTDO)
  1928.    {
  1929.    return;
  1930.    }
  1931.  
  1932. if ((pp = cfpopen(command,"r")) == NULL)
  1933.    {
  1934.    sprintf(OUTPUT,"Couldn't open pipe to command %s\n",command);
  1935.    CfLog(cfinform,OUTPUT,"pipe");
  1936.    return false;
  1937.    }
  1938.  
  1939. bzero(buffer,bufsize);
  1940.   
  1941. while (!feof(pp))
  1942.    {
  1943.    if (ferror(pp))  /* abortable */
  1944.       {
  1945.       fflush(pp);
  1946.       break;
  1947.       }
  1948.  
  1949.    ReadLine(line,bufsize,pp);
  1950.  
  1951.    if (ferror(pp))  /* abortable */
  1952.       {
  1953.       fflush(pp);
  1954.       break;
  1955.       }     
  1956.  
  1957.    for (sp = line; *sp != '\0'; sp++)
  1958.       {
  1959.       if (*sp == '\n')
  1960.      {
  1961.      *sp = ' ';
  1962.      }
  1963.       }
  1964.  
  1965.    if (strlen(line)+offset > bufsize-10)
  1966.       {
  1967.       sprintf(OUTPUT,"Buffer exceeded %d bytes in exec %s\n",maxvarsize,command);
  1968.       CfLog(cferror,OUTPUT,"");
  1969.       break;
  1970.       }
  1971.  
  1972.    sprintf(buffer+offset,"%s ",line);
  1973.    offset += strlen(line)+1;
  1974.    }
  1975.  
  1976. if (offset > 0)
  1977.    {
  1978.    Chop(buffer); 
  1979.    }
  1980.  
  1981. Debug("GetExecOutput got: [%s]\n",buffer);
  1982.  
  1983. cfpclose(pp);
  1984. return true; 
  1985. }
  1986.  
  1987. /********************************************************************/
  1988.  
  1989. InstallEditFile(file,edit,data)
  1990.  
  1991. char *file,*edit,*data;
  1992.  
  1993. { struct Edit *ptr;
  1994.  
  1995. if (data == NULL)
  1996.    {
  1997.    Debug1("InstallEditFile(%s,%s,-)\n",file,edit);
  1998.    }
  1999. else
  2000.    {
  2001.    Debug1("InstallEditFile(%s,%s,%s)\n",file,edit,data);
  2002.    }
  2003.  
  2004. if ( ! IsInstallable(CLASSBUFF))
  2005.    {
  2006.    InitializeAction();
  2007.    Debug1("Not installing Edit no match\n");
  2008.    return;
  2009.    }
  2010.  
  2011. bzero(VBUFF,bufsize);
  2012.  
  2013. ExpandVarstring(file,VBUFF,"");
  2014.  
  2015. if ((ptr = (struct Edit *)malloc(sizeof(struct Edit))) == NULL)
  2016.    {
  2017.    FatalError("Memory Allocation failed for InstallEditFile() #1");
  2018.    }
  2019.  
  2020. if ((ptr->fname = strdup(VBUFF)) == NULL)
  2021.    {
  2022.    FatalError("Memory Allocation failed for InstallEditFile() #2");
  2023.    }
  2024.  
  2025. if (VEDITLISTTOP == NULL)                 /* First element in the list */
  2026.    {
  2027.    VEDITLIST = ptr;
  2028.    }
  2029. else
  2030.    {
  2031.    VEDITLISTTOP->next = ptr;
  2032.    }
  2033.  
  2034. if (strncmp(VBUFF,"home",4) && strlen(VBUFF) < 6)
  2035.    {
  2036.    yyerror("Can't edit home directories: missing a filename after home");
  2037.    }
  2038.  
  2039. ptr->next = NULL;
  2040. ptr->actions = NULL;
  2041. VEDITLISTTOP = ptr;
  2042. AddEditAction(file,edit,data);
  2043. }
  2044.  
  2045. /********************************************************************/
  2046.  
  2047. AddEditAction(file,edit,data)
  2048.  
  2049. char *file,*edit,*data;
  2050.  
  2051. { struct Edit *ptr;
  2052.   struct Edlist *top,*new;
  2053.   char varbuff[bufsize];
  2054.  
  2055. if (data == NULL)
  2056.    {
  2057.    Debug2("AddEditAction(%s,%s,-)\n",file,edit);
  2058.    }
  2059. else
  2060.    {
  2061.    Debug2("AddEditAction(%s,%s,%s)\n",file,edit,data);
  2062.    }
  2063.  
  2064. if ( ! IsInstallable(CLASSBUFF))
  2065.    {
  2066.    Debug1("Not installing Edit no match\n");
  2067.    return;
  2068.    }
  2069.  
  2070. for (ptr = VEDITLIST; ptr != NULL; ptr=ptr->next)
  2071.    {
  2072.    varbuff[0] = '\0';
  2073.    ExpandVarstring(file,varbuff,"");
  2074.  
  2075.    if (strcmp(ptr->fname,varbuff) == 0)
  2076.       {
  2077.       if ((new = (struct Edlist *)malloc(sizeof(struct Edlist))) == NULL)
  2078.          {
  2079.          FatalError("Memory Allocation failed for AddEditAction() #1");
  2080.          }
  2081.  
  2082.       if (ptr->actions == NULL)
  2083.          {
  2084.          ptr->actions = new;
  2085.          }
  2086.       else
  2087.          {
  2088.          for (top = ptr->actions; top->next != NULL; top=top->next)
  2089.             {
  2090.             }
  2091.          top->next = new;
  2092.          }
  2093.  
  2094.       if (data == NULL)
  2095.          {
  2096.          new->data = NULL;
  2097.          }
  2098.       else
  2099.          {
  2100.          VBUFF[0]='\0';                         /* Expand any variables */
  2101.          ExpandVarstring(data,VBUFF,"");
  2102.  
  2103.          if ((new->data = strdup(VBUFF)) == NULL)
  2104.             {
  2105.             FatalError("Memory Allocation failed for AddEditAction() #1");
  2106.             }
  2107.          }
  2108.  
  2109.       new->next = NULL;
  2110.  
  2111.       if ((new->classes = strdup(CLASSBUFF)) == NULL)
  2112.          {
  2113.          FatalError("Memory Allocation failed for InstallEditFile() #3");
  2114.          }
  2115.  
  2116.       if ((new->code = EditActionsToCode(edit)) == NoEdit)
  2117.          {
  2118.          yyerror("Unknown edit action");
  2119.          }
  2120.  
  2121.       switch(new->code)
  2122.          {
  2123.          case BeginGroupIfNoMatch:
  2124.          case BeginGroupIfNoLineMatching:
  2125.          case BeginGroupIfNoLineContaining:
  2126.          case BeginGroupIfNoSuchLine:
  2127.      case BeginGroupIfFileIsNewer:
  2128.      case BeginGroupIfFileExists:
  2129.                 EDITGROUPLEVEL++;
  2130.                 break;
  2131.          case EndGroup:
  2132.                 EDITGROUPLEVEL--;
  2133.         if (EDITGROUPLEVEL < 0)
  2134.            {
  2135.            yyerror("EndGroup without Begin");
  2136.            }
  2137.                 break;
  2138.          case ReplaceAll:
  2139.             if (SEARCHREPLACELEVEL > 0)
  2140.            {
  2141.            yyerror("ReplaceAll without With before or at line");
  2142.            }
  2143.         
  2144.                 SEARCHREPLACELEVEL++;
  2145.                 break;
  2146.          case With:
  2147.                 SEARCHREPLACELEVEL--;
  2148.                 break;
  2149.      case ForEachLineIn:
  2150.             if (FOREACHLEVEL > 0)
  2151.            {
  2152.            yyerror("Nested ForEach loops not allowed");
  2153.            }
  2154.         
  2155.             FOREACHLEVEL++;
  2156.         break;
  2157.      case EndLoop:
  2158.             FOREACHLEVEL--;
  2159.         if (FOREACHLEVEL < 0)
  2160.            {
  2161.            yyerror("EndLoop without ForEachLineIn");
  2162.            }
  2163.         break;
  2164.      case SetLine:
  2165.             if (FOREACHLEVEL > 0)
  2166.            {
  2167.            yyerror("SetLine inside ForEachLineIn loop");
  2168.            }
  2169.             break;
  2170.      case FixEndOfLine:
  2171.             if (strlen(data) > extra_space - 1)
  2172.            {
  2173.            yyerror("End of line type is too long!");
  2174.            printf("          (max %d characters allowed)\n",extra_space);
  2175.            }
  2176.         break;
  2177.      case ReplaceLinesMatchingField:
  2178.             if (atoi(data) == 0)
  2179.            {
  2180.            yyerror("Argument must be an integer, greater than zero");
  2181.            }
  2182.      case DefineClasses:
  2183.                AddInstallable(new->data);
  2184.          }
  2185.  
  2186.       return;
  2187.       }
  2188.    }
  2189.  
  2190. printf("cfengine: software error - no file matched installing %s edit\n",file);
  2191. }
  2192.  
  2193. /********************************************************************/
  2194.  
  2195. enum editnames EditActionsToCode(edit)
  2196.  
  2197. char *edit;
  2198.  
  2199. { int i;
  2200.  
  2201. Debug2("EditActionsToCode(%s)\n",edit);
  2202.  
  2203. for (i = 0; VEDITNAMES[i] != '\0'; i++)
  2204.    {
  2205.    if (strcmp(VEDITNAMES[i],edit) == 0)
  2206.       {
  2207.       return (enum editnames) i;
  2208.       }
  2209.    }
  2210.  
  2211. return (NoEdit);
  2212. }
  2213.  
  2214.  
  2215. /********************************************************************/
  2216.  
  2217. AppendInterface(ifname,netmask,broadcast)
  2218.  
  2219. char *ifname,*netmask,*broadcast;
  2220.  
  2221. { struct Interface *ifp;
  2222.  
  2223. Debug1("Installing item (%s:%s:%s) in the interfaces list\n",ifname,netmask,broadcast);
  2224.  
  2225. if (!IsInstallable(CLASSBUFF))
  2226.    {
  2227.    InitializeAction();
  2228.    Debug1("Not installing %s, no match\n",ifname);
  2229.    return;
  2230.    }
  2231.  
  2232. if (strlen(netmask) < 7)
  2233.    {
  2234.    yyerror("illegal or missing netmask");
  2235.    InitializeAction();
  2236.    return;
  2237.    }
  2238.  
  2239. if (strlen(broadcast) < 3)
  2240.    {
  2241.    yyerror("illegal or missing broadcast address");
  2242.    InitializeAction();
  2243.    return;
  2244.    }
  2245.  
  2246. if ((ifp = (struct Interface *)malloc(sizeof(struct Interface))) == NULL)
  2247.    {
  2248.    FatalError("Memory Allocation failed for AppendInterface() #1");
  2249.    }
  2250.  
  2251. if ((ifp->classes = strdup(CLASSBUFF)) == NULL)
  2252.    {
  2253.    FatalError("Memory Allocation failed for Appendinterface() #2");
  2254.    }
  2255.  
  2256. if ((ifp->ifdev = strdup(ifname)) == NULL)
  2257.    {
  2258.    FatalError("Memory Allocation failed for AppendInterface() #3");
  2259.    }
  2260.  
  2261. if ((ifp->netmask = strdup(netmask)) == NULL)
  2262.    {
  2263.    FatalError("Memory Allocation failed for AppendInterface() #3");
  2264.    }
  2265.  
  2266. if ((ifp->broadcast = strdup(broadcast)) == NULL)
  2267.    {
  2268.    FatalError("Memory Allocation failed for AppendInterface() #3");
  2269.    } 
  2270.  
  2271. if (VIFLISTTOP == NULL)                 /* First element in the list */
  2272.    {
  2273.    VIFLIST = ifp;
  2274.    }
  2275.  else
  2276.     {
  2277.     VIFLISTTOP->next = ifp;
  2278.     }
  2279.  
  2280. ifp->next = NULL;
  2281.    
  2282. VIFLISTTOP = ifp;
  2283.  
  2284. InitializeAction(); 
  2285. }
  2286.  
  2287. /*******************************************************************/
  2288.  
  2289. AppendScript(item,timeout,useshell,uidname,gidname)
  2290.  
  2291. char *item, useshell,*uidname,*gidname;
  2292. int timeout;
  2293.  
  2294. { struct TwoDimList *tp = NULL;
  2295.   struct ShellComm *ptr;
  2296.   struct passwd *pw;
  2297.   struct group *gw;
  2298.   char *sp;
  2299.   int uid = CF_NOUSER; 
  2300.   int gid = CF_NOUSER;
  2301.   
  2302. Debug1("Installing item (%s) in the script list\n",item);
  2303.  
  2304. if ( ! IsInstallable(CLASSBUFF))
  2305.    {
  2306.    InitializeAction();
  2307.    Debug1("Not installing %s, no match\n",item);
  2308.    return;
  2309.    }
  2310.  
  2311. Build2DListFromVarstring(&tp,item,' '); /* Must be at least one space between each var */
  2312.  
  2313. Set2DList(tp);
  2314.  
  2315. for (sp = Get2DListEnt(tp); sp != NULL; sp = Get2DListEnt(tp))
  2316.    {
  2317.    if (*sp != '/')
  2318.       {
  2319.       yyerror("scripts or commands must have absolute path names");
  2320.       printf ("cfengine: concerns: %s\n",sp);
  2321.       return;
  2322.       }
  2323.  
  2324.    if ((ptr = (struct ShellComm *)malloc(sizeof(struct ShellComm))) == NULL)
  2325.       {
  2326.       FatalError("Memory Allocation failed for AppendScript() #1");
  2327.       }
  2328.  
  2329.    if ((ptr->classes = strdup(CLASSBUFF)) == NULL)
  2330.       {
  2331.       FatalError("Memory Allocation failed for Appendscript() #2");
  2332.       }
  2333.  
  2334.    if ((ptr->name = strdup(sp)) == NULL)
  2335.       {
  2336.       FatalError("Memory Allocation failed for Appendscript() #3");
  2337.       }
  2338.  
  2339.    if (VSCRIPTTOP == NULL)                 /* First element in the list */
  2340.       {
  2341.       VSCRIPT = ptr;
  2342.       }
  2343.    else
  2344.       {
  2345.       VSCRIPTTOP->next = ptr;
  2346.       }
  2347.  
  2348.  
  2349.    if (*uidname == '*')
  2350.       {
  2351.       ptr->uid = -1;      
  2352.       }
  2353.    else if (isdigit(*uidname))
  2354.       {
  2355.       sscanf(uidname,"%d",&uid);
  2356.       if (uid == CF_NOUSER)
  2357.      {
  2358.      yyerror("Unknown or silly user id");
  2359.      return;
  2360.      }
  2361.       else
  2362.      {
  2363.      ptr->uid = uid;
  2364.      }
  2365.       }
  2366.    else if ((pw = getpwnam(uidname)) == NULL)
  2367.       {
  2368.       yyerror("Unknown or silly user id");
  2369.       return;
  2370.       }
  2371.    else
  2372.       {
  2373.       ptr->uid = pw->pw_uid;
  2374.       }
  2375.  
  2376.    if (*gidname == '*')
  2377.       {
  2378.       ptr->gid = -1;
  2379.       }
  2380.    else if (isdigit(*gidname))
  2381.       {
  2382.       sscanf(gidname,"%d",&gid);
  2383.       if (gid == CF_NOUSER)
  2384.      {
  2385.      yyerror("Unknown or silly group id");
  2386.      continue;
  2387.      }
  2388.       else
  2389.      {
  2390.      ptr->gid = gid;
  2391.      }
  2392.       }
  2393.    else if ((gw = getgrnam(gidname)) == NULL)
  2394.       {
  2395.       yyerror("Unknown or silly group id");
  2396.       continue;
  2397.       }
  2398.    else
  2399.       {
  2400.       ptr->gid = gw->gr_gid;
  2401.       }
  2402.  
  2403.    ptr->log = LOGP;
  2404.    ptr->inform = INFORMP;
  2405.    ptr->timeout = timeout;
  2406.    ptr->useshell = useshell;
  2407.    ptr->next = NULL;
  2408.    
  2409.    if ((ptr->defines = strdup(ALLCLASSBUFFER)) == NULL)
  2410.       {
  2411.       FatalError("Memory Allocation failed for AppendDisable() #3");
  2412.       }
  2413.    
  2414.    AddInstallable(ptr->defines);
  2415.    VSCRIPTTOP = ptr;
  2416.    }
  2417.  
  2418. Delete2DList(tp);
  2419. }
  2420.  
  2421. /********************************************************************/
  2422.  
  2423. AppendDisable(path,type,rotate,comp,size,defines)
  2424.  
  2425. char *path, *type, comp, *defines;
  2426. short rotate;
  2427. int size;
  2428.  
  2429. { char buf2[bufsize],*sp;
  2430.   struct Disable *ptr;
  2431.   struct TwoDimList *tp = NULL;
  2432.  
  2433. Debug1("Installing item (%s) in the disable list\n",path);
  2434.  
  2435. if ( ! IsInstallable(CLASSBUFF))
  2436.    {
  2437.    InitializeAction();
  2438.    Debug1("Not installing %s, no match\n",path);
  2439.    return;
  2440.    }
  2441.  
  2442. Build2DListFromVarstring(&tp,path,' '); /* Must be at least one space between each var */
  2443.  
  2444. Set2DList(tp);
  2445.  
  2446. for (sp = Get2DListEnt(tp); sp != NULL; sp = Get2DListEnt(tp))
  2447.    {
  2448.    if (strlen(type) > 0 && strcmp(type,"plain") != 0 && strcmp(type,"file") !=0 && strcmp(type,"link") !=0
  2449.        && strcmp(type,"links") !=0 )
  2450.       {
  2451.       yyerror("Invalid file type in Disable");
  2452.       }
  2453.  
  2454.    bzero(VBUFF,bufsize);
  2455.    bzero(buf2,bufsize); 
  2456.    
  2457.    ExpandVarstring(defines,buf2,"");
  2458.    
  2459.    if ((ptr = (struct Disable *)malloc(sizeof(struct Disable))) == NULL)
  2460.       {
  2461.       FatalError("Memory Allocation failed for AppendDisable() #1");
  2462.       }
  2463.    
  2464.    if ((ptr->name = strdup(sp)) == NULL)
  2465.       {
  2466.       FatalError("Memory Allocation failed for AppendDisable() #2");
  2467.       }
  2468.    
  2469.    if ((ptr->defines = strdup(buf2)) == NULL)
  2470.       {
  2471.       FatalError("Memory Allocation failed for AppendDisable() #3");
  2472.       } 
  2473.    
  2474.    if ((ptr->classes = strdup(CLASSBUFF)) == NULL)
  2475.       {
  2476.       FatalError("Memory Allocation failed for AppendDisable() #4");
  2477.       }
  2478.    
  2479.    if (strlen(type) == 0)
  2480.       {
  2481.       sprintf(VBUFF,"all");
  2482.       }
  2483.    else
  2484.       {
  2485.       sprintf(VBUFF,"%s",type);
  2486.       }
  2487.    
  2488.    if ((ptr->type = strdup(VBUFF)) == NULL)
  2489.       {
  2490.       FatalError("Memory Allocation failed for AppendDisable() #4");
  2491.       }
  2492.    
  2493.    if (! IsItemIn(VALLADDCLASSES,buf2))
  2494.       {
  2495.       AppendItem(&VALLADDCLASSES,buf2,NULL);
  2496.       }
  2497.    
  2498.    if (VDISABLETOP == NULL)                 /* First element in the list */
  2499.       {
  2500.       VDISABLELIST = ptr;
  2501.       }
  2502.    else
  2503.       {
  2504.       VDISABLETOP->next = ptr;
  2505.       }
  2506.    
  2507.    ptr->rotate = rotate;
  2508.    ptr->comp = comp;
  2509.    ptr->size = size;
  2510.    ptr->next = NULL;
  2511.    ptr->log = LOGP;
  2512.    ptr->inform = INFORMP;
  2513.    
  2514.    VDISABLETOP = ptr;
  2515.    InitializeAction();
  2516.    AddInstallable(ptr->defines);
  2517.    }
  2518.  
  2519.  Delete2DList(tp);  
  2520. }
  2521.  
  2522. /*******************************************************************/
  2523.  
  2524. InstallTidyItem (path,wild,rec,age,travlinks,tidysize,type,ldirs,tidydirs,classes,defines)
  2525.  
  2526. char *wild, *path;
  2527. short age,tidydirs;
  2528. int rec,tidysize;
  2529. char type, ldirs, *classes, *defines, travlinks;
  2530.  
  2531. { struct TwoDimList *tp = NULL;
  2532.   char *sp;
  2533.  
  2534. if (strcmp(path,"/") != 0)
  2535.    {
  2536.    DeleteSlash(path);
  2537.    }
  2538.  
  2539. Build2DListFromVarstring(&tp,path,'/');
  2540.  
  2541. Set2DList(tp);
  2542.  
  2543. for (sp = Get2DListEnt(tp); sp != NULL; sp = Get2DListEnt(tp))
  2544.    {
  2545.    if (TidyPathExists(sp))
  2546.       {
  2547.       AddTidyItem(sp,wild,rec,age,travlinks,tidysize,type,ldirs,tidydirs,classes,defines);
  2548.       }
  2549.    else
  2550.       {
  2551.       InstallTidyPath(sp,wild,rec,age,travlinks,tidysize,type,ldirs,tidydirs,classes,defines);
  2552.       }
  2553.    }
  2554.  
  2555. Delete2DList(tp);
  2556. InitializeAction();
  2557. }
  2558.  
  2559. /*******************************************************************/
  2560.  
  2561. InstallMakePath(path,plus,minus,uidnames,gidnames,defines)
  2562.  
  2563. char *path, *defines;
  2564. mode_t plus,minus;
  2565. char *uidnames;
  2566. char *gidnames;
  2567.  
  2568. { struct File *ptr;
  2569.   char buffer[bufsize]; 
  2570.  
  2571. Debug1("InstallMakePath (%s) (+%o)(-%o)(%s)(%s)\n",path,plus,minus,uidnames,gidnames);
  2572.  
  2573. if ( ! IsInstallable(CLASSBUFF))
  2574.    {
  2575.    InitializeAction();
  2576.    Debug1("Not installing directory item, no match\n");
  2577.    return;
  2578.    }
  2579.  
  2580. VBUFF[0]='\0';                                /* Expand any variables */
  2581. ExpandVarstring(path,VBUFF,"");
  2582.  
  2583. bzero(buffer,bufsize);
  2584. ExpandVarstring(ALLCLASSBUFFER,buffer,""); 
  2585.  
  2586. if ((ptr = (struct File *)malloc(sizeof(struct File))) == NULL)
  2587.    {
  2588.    FatalError("Memory Allocation failed for InstallMakepath() #1");
  2589.    }
  2590.  
  2591. if ((ptr->path = strdup(VBUFF)) == NULL)
  2592.    {
  2593.    FatalError("Memory Allocation failed for InstallMakepath() #2");
  2594.    }
  2595.  
  2596. if ((ptr->classes = strdup(CLASSBUFF)) == NULL)
  2597.    {
  2598.    FatalError("Memory Allocation failed for InstallMakepath() #3");
  2599.    }
  2600.  
  2601. if ((ptr->defines = strdup(buffer)) == NULL)
  2602.    {
  2603.    FatalError("Memory Allocation failed for InstallMakepath() #3a");
  2604.    }
  2605.  
  2606. AddInstallable(ptr->defines); 
  2607.  
  2608. if (VMAKEPATHTOP == NULL)                 /* First element in the list */
  2609.    {
  2610.    VMAKEPATH = ptr;
  2611.    }
  2612. else
  2613.    {
  2614.    VMAKEPATHTOP->next = ptr;
  2615.    }
  2616.  
  2617. ptr->plus = plus;
  2618. ptr->minus = minus;
  2619. ptr->recurse = 0;
  2620. ptr->action = fixdirs;
  2621. ptr->uid = MakeUidList(uidnames);
  2622. ptr->gid = MakeGidList(gidnames);
  2623. ptr->inclusions = NULL;
  2624. ptr->exclusions = NULL;
  2625. ptr->acl_aliases= VACLBUILD; 
  2626. ptr->log = LOGP;
  2627. ptr->inform = INFORMP;
  2628. ptr->plus_flags = PLUSFLAG;
  2629. ptr->minus_flags = MINUSFLAG;
  2630.  
  2631. ptr->next = NULL;
  2632. VMAKEPATHTOP = ptr;
  2633. InitializeAction();
  2634. }
  2635.  
  2636. /*******************************************************************/
  2637.  
  2638. HandleTravLinks(value)
  2639.  
  2640. char *value;
  2641.  
  2642. {
  2643. if (ACTION == tidy && strncmp(CURRENTPATH,"home",4) == 0)
  2644.    {
  2645.    yyerror("Can't use links= option with special variable home in tidy");
  2646.    yyerror("Use command line options instead.\n");
  2647.    }
  2648.  
  2649. if (PTRAVLINKS != '?')
  2650.    {
  2651.    Warning("redefinition of links= option");
  2652.    }
  2653.  
  2654. if ((strcmp(value,"stop") == 0) || (strcmp(value,"false") == 0))
  2655.    {
  2656.    PTRAVLINKS = (short) 'F';
  2657.    return;
  2658.    }
  2659.  
  2660. if ((strcmp(value,"traverse") == 0) || (strcmp(value,"follow") == 0) || (strcmp(value,"true") == 0))
  2661.    {
  2662.    PTRAVLINKS = (short) 'T';
  2663.    return;
  2664.    }
  2665.  
  2666. if ((strcmp(value,"tidy"))==0)
  2667.    {
  2668.    PTRAVLINKS = (short) 'K';
  2669.    return;
  2670.    }
  2671.  
  2672. yyerror("Illegal links= specifier");
  2673. }
  2674.  
  2675. /*******************************************************************/
  2676.  
  2677. HandleTidySize(value)
  2678.  
  2679. char *value;
  2680.  
  2681. { int num = -1;
  2682.   char *sp, units = 'k';
  2683.  
  2684. for (sp = value; *sp != '\0'; sp++)
  2685.    {
  2686.    *sp = ToLower(*sp);
  2687.    }
  2688.  
  2689. if (strcmp(value,"empty") == 0)
  2690.    {
  2691.    TIDYSIZE = CF_EMPTYFILE;
  2692.    }
  2693. else
  2694.    {
  2695.    sscanf(value,"%d%c",&num,&units);
  2696.  
  2697.    if (num <= 0)
  2698.       {
  2699.       yyerror("disable/rotate value must be a decimal number >= zero or keyword empty");
  2700.       }
  2701.  
  2702.    switch (units)
  2703.       {
  2704.       case 'b': TIDYSIZE = num;
  2705.             break;
  2706.       case 'm': TIDYSIZE = num * 1024 * 1024;
  2707.             break;
  2708.       default:  TIDYSIZE = num * 1024;
  2709.       }
  2710.    }
  2711.  
  2712. }
  2713.  
  2714. /*******************************************************************/
  2715.  
  2716. HandleDisableSize(value)
  2717.  
  2718. char *value;
  2719.  
  2720. { int i = -1;
  2721.   char *sp, units = 'b';
  2722.  
  2723. for (sp = value; *sp != '\0'; sp++)
  2724.    {
  2725.    *sp = ToLower(*sp);
  2726.    }
  2727.  
  2728. switch (*value)
  2729.    {
  2730.    case '>': DISCOMP = '>';
  2731.              value++;
  2732.              break;
  2733.    case '<': DISCOMP = '<';
  2734.              value++;
  2735.              break;
  2736.    default : DISCOMP = '=';
  2737.    }
  2738.  
  2739. sscanf(value,"%d%c",&i,&units);
  2740.  
  2741. if (i < 1)
  2742.    {
  2743.    yyerror("disable size attribute with silly value (must be > 0)");
  2744.    }
  2745.  
  2746. switch (units)
  2747.    {
  2748.    case 'k': DISABLESIZE = i * 1024;
  2749.              break;
  2750.    case 'm': DISABLESIZE = i * 1024 * 1024;
  2751.              break;
  2752.    default:  DISABLESIZE = i;
  2753.    }
  2754. }
  2755.  
  2756. /*******************************************************************/
  2757.  
  2758. HandleCopySize(value)
  2759.  
  2760. char *value;
  2761.  
  2762. { int i = -1;
  2763.   char *sp, units = 'b';
  2764.  
  2765. for (sp = value; *sp != '\0'; sp++)
  2766.    {
  2767.    *sp = ToLower(*sp);
  2768.    }
  2769.  
  2770. switch (*value)
  2771.    {
  2772.    case '>': IMGCOMP = '>';
  2773.              value++;
  2774.              break;
  2775.    case '<': IMGCOMP = '<';
  2776.              value++;
  2777.              break;
  2778.    default : IMGCOMP = '=';
  2779.    }
  2780.  
  2781. sscanf(value,"%d%c",&i,&units);
  2782.  
  2783. if (i < 0)
  2784.    {
  2785.    yyerror("copy size attribute with silly value (must be a non-negative number)");
  2786.    }
  2787.  
  2788. switch (units)
  2789.    {
  2790.    case 'k': IMGSIZE = i * 1024;
  2791.              break;
  2792.    case 'm': IMGSIZE = i * 1024 * 1024;
  2793.              break;
  2794.    default:  IMGSIZE = i;
  2795.    }
  2796. }
  2797.  
  2798. /*******************************************************************/
  2799.  
  2800. HandlePurge(value)
  2801.  
  2802. char *value;
  2803.  
  2804. {
  2805. Debug1("HandlePurge(%s)\n",value);
  2806.   
  2807. if ((strcmp(value,"true") == 0) || (strcmp(value,"on") == 0))
  2808.    {
  2809.    PURGE = 'y';
  2810.    return;
  2811.    }
  2812.  
  2813. if ((strcmp(value,"false") == 0) || (strcmp(value,"off") == 0))
  2814.    {
  2815.    PURGE = 'n';
  2816.    return;
  2817.    }
  2818.  
  2819. yyerror("Illegal purge value");
  2820. }
  2821.  
  2822. /*******************************************************************/
  2823.  
  2824. HandleRequiredSize(value)
  2825.  
  2826. char *value;
  2827.  
  2828. { int i = -1;
  2829.   char *sp, units = 'b';
  2830.  
  2831. for (sp = value; *sp != '\0'; sp++)
  2832.    {
  2833.    *sp = ToLower(*sp);
  2834.    }
  2835.  
  2836. switch (*value)
  2837.    {
  2838.    case '>': IMGCOMP = '>';
  2839.              value++;
  2840.              break;
  2841.    case '<': IMGCOMP = '<';
  2842.              value++;
  2843.              break;
  2844.    default : IMGCOMP = '=';
  2845.    }
  2846.  
  2847. sscanf(value,"%d%c",&i,&units);
  2848.  
  2849. if (i < 1)
  2850.    {
  2851.    yyerror("disk/required size attribute with silly value (must be > 0)");
  2852.    }
  2853.  
  2854. switch (units)
  2855.    {
  2856.    case 'b': IMGSIZE = i / 1024;
  2857.              break;
  2858.    case 'm': IMGSIZE = i * 1024;
  2859.              break;
  2860.    case '%': IMGSIZE = -i;       /* -ve number signals percentage */
  2861.              break;
  2862.    default:  IMGSIZE = i;
  2863.    }
  2864. }
  2865.  
  2866. /*******************************************************************/
  2867.  
  2868. HandleTidyType(value)
  2869.  
  2870. char *value;
  2871.  
  2872. {
  2873. if (strcmp(value,"a")== 0 || strcmp(value,"atime") == 0)
  2874.    {
  2875.    AGETYPE = 'a';
  2876.    return;
  2877.    }
  2878.  
  2879. if (strcmp(value,"m")== 0 || strcmp(value,"mtime") == 0)
  2880.    {
  2881.    AGETYPE = 'm';
  2882.    return;
  2883.    }
  2884.  
  2885. if (strcmp(value,"c")== 0 || strcmp(value,"ctime") == 0)
  2886.    {
  2887.    AGETYPE = 'c';
  2888.    return;
  2889.    }
  2890.  
  2891. yyerror("Illegal age search type, must be atime/ctime/mtime");
  2892. }
  2893.  
  2894. /*******************************************************************/
  2895.  
  2896. HandleTidyLinkDirs(value)
  2897.  
  2898. char *value;
  2899.  
  2900. {
  2901. if (strcmp(value,"keep")== 0)
  2902.    {
  2903.    LINKDIRS = 'k';
  2904.    return;
  2905.    }
  2906.  
  2907. if (strcmp(value,"tidy")== 0 || strcmp(value,"delete") == 0)
  2908.    {
  2909.    LINKDIRS = 't';
  2910.    return;
  2911.    }
  2912.  
  2913. yyerror("Illegal linkdirs value, must be keep/delete/tidy");
  2914. }
  2915.  
  2916. /*******************************************************************/
  2917.  
  2918. HandleTidyRmdirs(value)
  2919.  
  2920. char *value;
  2921.  
  2922. {
  2923. if ((strcmp(value,"true") == 0)||(strcmp(value,"all") == 0))
  2924.    {
  2925.    TIDYDIRS = 1;
  2926.    return;
  2927.    }
  2928.  
  2929. if ((strcmp(value,"false") == 0)||(strcmp(value,"none") == 0))
  2930.    {
  2931.    TIDYDIRS = 0;
  2932.    return;
  2933.    }
  2934.  
  2935. if (strcmp(value,"sub") == 0)
  2936.    {
  2937.    TIDYDIRS = 2;
  2938.    return;
  2939.    }
  2940.  
  2941. yyerror("Illegal rmdirs value, must be true/false");
  2942. }
  2943.  
  2944. /*******************************************************************/
  2945.  
  2946. HandleForceCopy(value)
  2947.  
  2948. char *value;
  2949.  
  2950. {
  2951. if (strcmp(value,"true") == 0 || strcmp(value,"on") == 0)
  2952.    {
  2953.    FORCECOPY = true;
  2954.    return;
  2955.    }
  2956.  
  2957. if (strcmp(value,"false") == 0 || strcmp(value,"off") == 0)
  2958.    {
  2959.    FORCECOPY = false;
  2960.    return;
  2961.    }
  2962.  
  2963. yyerror("Illegal copy attribute for force= ");
  2964. }
  2965.  
  2966. /*******************************************************************/
  2967.  
  2968. HandleCopyBackup(value)
  2969.  
  2970. char *value;
  2971.  
  2972. {
  2973. if (strcmp(value,"true") == 0 || strcmp(value,"on") == 0)
  2974.    {
  2975.    IMAGEBACKUP = true;
  2976.    return;
  2977.    }
  2978.  
  2979. if (strcmp(value,"false") == 0 || strcmp(value,"off") == 0)
  2980.    {
  2981.    IMAGEBACKUP = false;
  2982.    return;
  2983.    }
  2984.  
  2985. yyerror("Illegal copy attribute for backup= ");
  2986. }
  2987.  
  2988. /*******************************************************************/
  2989.  
  2990. HandleTimeOut(value)
  2991.  
  2992. char *value;
  2993.  
  2994. { int num = -1;
  2995.  
  2996. sscanf(value,"%d",&num);
  2997.  
  2998. if (num <= 0)
  2999.    {
  3000.    yyerror("timeout value must be a decimal number > 0");
  3001.    }
  3002.  
  3003. VTIMEOUT = num;
  3004. }
  3005.  
  3006.  
  3007. /*******************************************************************/
  3008.  
  3009. HandleUseShell(value)
  3010.  
  3011. char *value;
  3012.  
  3013. {
  3014.  if (strcmp(value,"true") == 0)
  3015.    {
  3016.    USESHELL = 'y';
  3017.    return;
  3018.    }
  3019.  
  3020. if (strcmp(value,"false") == 0)
  3021.    {
  3022.    USESHELL = 'n';
  3023.    return;
  3024.    }
  3025.  
  3026. if (strcmp(value,"dumb") == 0)
  3027.    {
  3028.    USESHELL = 'd';
  3029.    return;
  3030.    }
  3031.  
  3032. yyerror("Illegal attribute for useshell= ");
  3033. }
  3034.  
  3035. /*******************************************************************/
  3036.  
  3037. HandleSetLog(value)
  3038.  
  3039. char *value;
  3040.  
  3041. {
  3042. if (strcmp(value,"true") == 0 || strcmp(value,"on") == 0)
  3043.    {
  3044.    LOGP = 't';
  3045.    return;
  3046.    }
  3047.  
  3048. if (strcmp(value,"false") == 0 || strcmp(value,"off") == 0)
  3049.    {
  3050.    LOGP = 'f';
  3051.    return;
  3052.    }
  3053.  
  3054. yyerror("Illegal attribute for log= ");
  3055. }
  3056.  
  3057. /*******************************************************************/
  3058.  
  3059. HandleSetInform(value)
  3060.  
  3061. char *value;
  3062.  
  3063. {
  3064. if (strcmp(value,"true") == 0 || strcmp(value,"on") == 0)
  3065.    {
  3066.    INFORMP = 't';
  3067.    return;
  3068.    }
  3069.  
  3070. if (strcmp(value,"false") == 0 || strcmp(value,"off") == 0)
  3071.    {
  3072.    INFORMP = 'f';
  3073.    return;
  3074.    }
  3075.  
  3076. yyerror("Illegal attribute for inform= ");
  3077. }
  3078.  
  3079. /*******************************************************************/
  3080.  
  3081. HandleSetSecure(value)
  3082.  
  3083. char *value;
  3084.  
  3085. {
  3086. if (strcmp(value,"true") == 0 || strcmp(value,"on") == 0)
  3087.    {
  3088.    SECURE = true;
  3089.    return;
  3090.    }
  3091.  
  3092. if (strcmp(value,"false") == 0 || strcmp(value,"off") == 0)
  3093.    {
  3094.    SECURE = false;
  3095.    return;
  3096.    }
  3097.  
  3098. yyerror("Illegal attribute for secure= ");
  3099. }
  3100.  
  3101. /*******************************************************************/
  3102.  
  3103. HandleChecksum(value)
  3104.  
  3105. char *value;
  3106.  
  3107. {
  3108. if (strcmp(value,"md5") == 0)
  3109.    {
  3110.    CHECKSUM = 'm';
  3111.    return;
  3112.    }
  3113.  
  3114. yyerror("Illegal attribute for checksum= ");
  3115. }
  3116.  
  3117. /*******************************************************************/
  3118.  
  3119. HandleStealth(value)
  3120.  
  3121. char *value;
  3122.  
  3123. {
  3124. if (strcmp(value,"true") == 0 || strcmp(value,"on") == 0)
  3125.    {
  3126.    STEALTH = 't';
  3127.    return;
  3128.    }
  3129.  
  3130. if (strcmp(value,"false") == 0 || strcmp(value,"off") == 0)
  3131.    {
  3132.    STEALTH = 'f';
  3133.    return;
  3134.    }
  3135.  
  3136. yyerror("Illegal attribute for stealth= ");
  3137. }
  3138.  
  3139.  
  3140. /*******************************************************************/
  3141.  
  3142. GetFileAction(action)
  3143.  
  3144. char *action;
  3145.  
  3146. { int i;
  3147.  
  3148. for (i = 0; FILEACTIONTEXT[i] != '\0'; i++)
  3149.    {
  3150.    if (strcmp(action,FILEACTIONTEXT[i]) == 0)
  3151.       {
  3152.       return i;
  3153.       }
  3154.    }
  3155.  
  3156. yyerror("Unknown action type");
  3157. return (int) warnall;
  3158. }
  3159.  
  3160.  
  3161. /*******************************************************************/
  3162.  
  3163. InstallFileListItem(path,plus,minus,action,uidnames,gidnames,recurse,travlinks,defines,chksum)
  3164.  
  3165. char *path, *defines;
  3166. mode_t plus,minus;
  3167. enum fileactions action;
  3168. char *uidnames;
  3169. char *gidnames;
  3170. int recurse;
  3171. char travlinks,chksum;
  3172.  
  3173. { struct File *ptr;
  3174.   char *spl;
  3175.   struct TwoDimList *tp = NULL;
  3176.  
  3177. Debug1("InstallFileaction (%s) (+%o)(-%o) (%s) (%d) (%c)\n",path,plus,minus,FILEACTIONTEXT[action],action,travlinks);
  3178.  
  3179. if ( ! IsInstallable(CLASSBUFF))
  3180.    {
  3181.    InitializeAction();
  3182.    Debug1("Not installing file item, no match\n");
  3183.    return;
  3184.    }
  3185.  
  3186. bzero(VBUFF,bufsize);
  3187. ExpandVarstring(ALLCLASSBUFFER,VBUFF,""); 
  3188.  
  3189. Build2DListFromVarstring(&tp,path,'/');
  3190.     
  3191. Set2DList(tp);
  3192.  
  3193. for (spl = Get2DListEnt(tp); spl != NULL; spl = Get2DListEnt(tp))
  3194.    {
  3195.    if ((ptr = (struct File *)malloc(sizeof(struct File))) == NULL)
  3196.       {
  3197.       FatalError("Memory Allocation failed for InstallFileListItem() #1");
  3198.       }
  3199.  
  3200.    if ((ptr->path = strdup(spl)) == NULL)
  3201.       {
  3202.       FatalError("Memory Allocation failed for InstallFileListItem() #2");
  3203.       }
  3204.  
  3205.    if ((ptr->classes = strdup(CLASSBUFF)) == NULL)
  3206.       {
  3207.       FatalError("Memory Allocation failed for InstallFileListItem() #3");
  3208.       }
  3209.  
  3210.    if ((ptr->defines = strdup(VBUFF)) == NULL)
  3211.       {
  3212.       FatalError("Memory Allocation failed for InstallFileListItem() #3");
  3213.       }
  3214.  
  3215.    AddInstallable(ptr->defines);
  3216.  
  3217.    if (VFILETOP == NULL)                 /* First element in the list */
  3218.       {
  3219.       VFILE = ptr;
  3220.       }
  3221.    else
  3222.       {
  3223.       VFILETOP->next = ptr;
  3224.       }
  3225.  
  3226.    ptr->action = action;
  3227.    ptr->plus = plus;
  3228.    ptr->minus = minus;
  3229.    ptr->recurse = recurse;
  3230.    ptr->uid = MakeUidList(uidnames);
  3231.    ptr->gid = MakeGidList(gidnames);
  3232.    ptr->exclusions = VEXCLUDEPARSE;
  3233.    ptr->inclusions = VINCLUDEPARSE;
  3234.    ptr->ignores = VIGNOREPARSE;
  3235.    ptr->travlinks = travlinks;
  3236.    ptr->acl_aliases  = VACLBUILD;
  3237.    ptr->next = NULL;
  3238.    ptr->log = LOGP;
  3239.    ptr->inform = INFORMP;
  3240.    ptr->checksum = chksum;
  3241.    ptr->plus_flags = PLUSFLAG;
  3242.    ptr->minus_flags = MINUSFLAG;
  3243.  
  3244.    VFILETOP = ptr;
  3245.    Debug1("Installed file object %s\n",spl);
  3246.    }
  3247.  
  3248. Delete2DList(tp);
  3249.  
  3250. InitializeAction();
  3251. }
  3252.  
  3253.  
  3254. /*******************************************************************/
  3255.  
  3256. InstallProcessItem(expr,restart,matches,comp,signal,action,classes,defines,useshell)
  3257.  
  3258. char *expr, *restart, *classes, *defines;
  3259. short matches, signal;
  3260. char action, comp, useshell;
  3261.  
  3262. { struct Process *ptr;
  3263.   char buf1[bufsize], buf2[bufsize], buf3[bufsize];
  3264.  
  3265. if (comp == 't')
  3266.    {
  3267.    comp = '=';
  3268.    }
  3269.  
  3270. Debug1("InstallProcessItem(%s,%s,%d,%d,%c)\n",expr,restart,matches,signal,action);
  3271.  
  3272. bzero(buf1,bufsize);
  3273. bzero(buf2,bufsize);
  3274. bzero(buf3,bufsize); 
  3275.  
  3276. ExpandVarstring(expr,buf1,"");
  3277. ExpandVarstring(restart,buf2,"");
  3278. ExpandVarstring(defines,buf3,""); 
  3279.  
  3280. if ( ! IsInstallable(CLASSBUFF))
  3281.    {
  3282.    InitializeAction();
  3283.    Debug1("Not installing process item, no match\n");
  3284.    return;
  3285.    }
  3286.  
  3287. if ((ptr = (struct Process *)malloc(sizeof(struct Process))) == NULL)
  3288.    {
  3289.    FatalError("Memory Allocation failed for InstallProcItem() #1");
  3290.    }
  3291.  
  3292. if ((ptr->expr = strdup(buf1)) == NULL)
  3293.    {
  3294.    FatalError("Memory Allocation failed for InstallProcItem() #2");
  3295.    }
  3296.  
  3297. if ((ptr->restart = strdup(buf2)) == NULL)
  3298.    {
  3299.    FatalError("Memory Allocation failed for InstallProcItem() #3");
  3300.    }
  3301.  
  3302. if ((ptr->defines = strdup(buf3)) == NULL)
  3303.    {
  3304.    FatalError("Memory Allocation failed for InstallProcItem() #4");
  3305.    }
  3306.  
  3307. if ((ptr->classes = strdup(CLASSBUFF)) == NULL)
  3308.    {
  3309.    FatalError("Memory Allocation failed for InstallProcItem() #5");
  3310.    }
  3311.  
  3312. if (VPROCTOP == NULL)                 /* First element in the list */
  3313.    {
  3314.    VPROCLIST = ptr;
  3315.    }
  3316. else
  3317.    {
  3318.    VPROCTOP->next = ptr;
  3319.    }
  3320.  
  3321. if (! IsItemIn(VALLADDCLASSES,buf3))
  3322.    {
  3323.    AppendItem(&VALLADDCLASSES,buf3,NULL);
  3324.    }
  3325.  
  3326. ptr->matches = matches;
  3327. ptr->comp = comp;
  3328. ptr->signal = signal;
  3329. ptr->action = action;
  3330. ptr->useshell = useshell; 
  3331. ptr->next = NULL;
  3332. ptr->log = LOGP;
  3333. ptr->inform = INFORMP;
  3334. ptr->exclusions = VEXCLUDEPARSE;
  3335. ptr->inclusions = VINCLUDEPARSE;
  3336. VPROCTOP = ptr;
  3337. InitializeAction();
  3338. AddInstallable(ptr->defines); 
  3339. }
  3340.  
  3341. /*******************************************************************/
  3342.  
  3343. InstallImageItem(path,plus,minus,destination,action,uidnames,gidnames,
  3344.          force,size,comp,backup,rec,type,lntype,server,classbuffer,
  3345.          purge,stealth,secure)
  3346.  
  3347. char *path, *destination, *action, *server, *classbuffer;
  3348. mode_t plus,minus;
  3349. char *uidnames;
  3350. char *gidnames;
  3351. short force;
  3352. short backup;
  3353. char type, lntype, comp, purge, stealth;
  3354. int rec, size;
  3355. short secure;
  3356.  
  3357. { struct Image *ptr;
  3358.   char *sp, *spl; 
  3359.   char buf1[bufsize], buf2[bufsize], buf3[bufsize], buf4[bufsize];
  3360.   struct TwoDimList *tp = NULL, *tpserv = NULL;
  3361.   int i;
  3362.   struct hostent *hp;
  3363.   
  3364. if ( ! IsInstallable(CLASSBUFF))
  3365.    {
  3366.    InitializeAction();
  3367.    Debug1("Not installing copy item, no match\n");
  3368.    return;
  3369.    }
  3370.   
  3371. Debug1("InstallImageItem (%s) (+%o)(-%o) (%s), server=%s\n",path,plus,minus,destination,server);
  3372.  
  3373. if (strlen(action) == 0)   /* default action */
  3374.    {
  3375.    strcat(action,"fix");
  3376.    }
  3377.  
  3378. if (!(strcmp(action,"silent") == 0 || strcmp(action,"warn") == 0 || strcmp(action,"fix") == 0))
  3379.    {
  3380.    sprintf(VBUFF,"Illegal action in image/copy item: %s",action);
  3381.    yyerror(VBUFF);
  3382.    return;
  3383.    }
  3384.  
  3385. bzero(buf1,bufsize);
  3386. bzero(buf3,bufsize);
  3387. bzero(buf4,bufsize);
  3388.  
  3389. ExpandVarstring(path,buf1,"");
  3390. ExpandVarstring(server,buf3,"");
  3391. ExpandVarstring(classbuffer,buf4,"");
  3392.  
  3393. if (strlen(buf1) > 1)
  3394.    {
  3395.    DeleteSlash(buf1);
  3396.    }
  3397.  
  3398. if (!FORCENETCOPY && ((strcmp(buf3,VFQNAME) == 0) || (strcmp(buf3,VUQNAME) == 0) || (strcmp(buf3,VSYSNAME.nodename) == 0)))
  3399.    {
  3400.    Debug("Swapping %s for localhost\n",server);
  3401.    strcpy(buf3,"localhost");
  3402.    }
  3403.  
  3404.  
  3405. Build2DListFromVarstring(&tp,path,'/');  /* Must split on space in comm string */
  3406.     
  3407. Set2DList(tp);
  3408.  
  3409. if ((ptr = (struct Image *)malloc(sizeof(struct Image))) == NULL)
  3410.    {
  3411.    FatalError("Memory Allocation failed for InstallImageItem() #1");
  3412.    }
  3413.  
  3414. if ((ptr->classes = strdup(CLASSBUFF)) == NULL)
  3415.    {
  3416.    FatalError("Memory Allocation failed for InstallImageItem() #3");
  3417.    }
  3418.  
  3419. if (strlen(buf3) > 128)
  3420.    {
  3421.    yyerror("Server name is too long");
  3422.    return;
  3423.    }
  3424.  
  3425. if ((ptr->server = strdup(buf3)) == NULL)
  3426.    {
  3427.    FatalError("Memory Allocation failed for InstallImageItem() #5");
  3428.    }
  3429.  
  3430. if ((ptr->action = strdup(action)) == NULL)
  3431.    {
  3432.    FatalError("Memory Allocation failed for InstallImageItem() #6");
  3433.    }
  3434.  
  3435. if ((ptr->defines = strdup(buf4)) == NULL)
  3436.    {
  3437.    FatalError("Memory Allocation failed for InstallImageItem() #7");
  3438.    }
  3439.  
  3440. for (spl = Get2DListEnt(tp); spl != NULL; spl = Get2DListEnt(tp))
  3441.    {
  3442.    if (strlen(destination) == 0)
  3443.       {
  3444.       strcpy(buf2,spl);
  3445.       }
  3446.    else
  3447.       {
  3448.       bzero(buf2,bufsize);
  3449.       ExpandVarstring(destination,buf2,"");
  3450.       }
  3451.  
  3452.    if (strlen(buf2) > 1)
  3453.    {
  3454.    DeleteSlash(buf2);
  3455.    }
  3456.  
  3457.    if (buf2[0] != '/')
  3458.       {
  3459.       if (strncmp(buf2,"home",4) == 0)
  3460.      {
  3461.      if (strlen(buf2) > 4 && buf2[4] != '/')
  3462.         {
  3463.         yyerror("illegal use of home or not absolute pathname");
  3464.         return;
  3465.         }
  3466.      }
  3467.       else
  3468.      {
  3469.      yyerror("Image needs an absolute pathname");
  3470.      return;
  3471.      }
  3472.       }
  3473.  
  3474.    if ((ptr->destination = strdup(buf2)) == NULL)
  3475.       {
  3476.       FatalError("Memory Allocation failed for InstallImageItem() #4");
  3477.       }
  3478.  
  3479.    if ((strcmp(spl,buf2) == 0) && (strcmp(buf3,"localhost") == 0))
  3480.       {
  3481.       yyerror("image loop: file/dir copies to itself or missing destination file");
  3482.       return;
  3483.       }
  3484.  
  3485.    if ((ptr->path = strdup(spl)) == NULL)
  3486.       {
  3487.       FatalError("Memory Allocation failed for InstallImageItem() #2");
  3488.       }
  3489.       
  3490.    if (VIMAGETOP == NULL)
  3491.       {
  3492.       VIMAGE = ptr;
  3493.       }
  3494.    else
  3495.       {
  3496.       VIMAGETOP->next = ptr;
  3497.       }
  3498.  
  3499.    ptr->plus = plus;
  3500.    ptr->minus = minus;
  3501.    ptr->uid = MakeUidList(uidnames);
  3502.    ptr->gid = MakeGidList(gidnames);
  3503.    ptr->force = force;
  3504.    ptr->next = NULL;
  3505.    ptr->backup = backup;
  3506.    ptr->recurse = rec;
  3507.    ptr->type = type;
  3508.    ptr->stealth = stealth;
  3509. #ifdef HAVE_LIBCRYPTO
  3510.    ptr->secure = secure;
  3511. #else
  3512.    ptr->secure = false;
  3513.    Verbose("Secure copying is not possible without libcrypto from OpenSSL\n");
  3514. #endif
  3515.    ptr->size = size;
  3516.    ptr->comp = comp;
  3517.    ptr->linktype = lntype;
  3518.    ptr->symlink = VCPLNPARSE;
  3519.    ptr->exclusions = VEXCLUDEPARSE;
  3520.    ptr->inclusions = VINCLUDEPARSE;
  3521.    ptr->ignores = VIGNOREPARSE;
  3522.    ptr->cache = NULL;
  3523.    ptr->purge = purge;
  3524.    ptr->log = LOGP;
  3525.    ptr->inform = INFORMP;
  3526.    ptr->plus_flags = PLUSFLAG;
  3527.    ptr->minus_flags = MINUSFLAG;
  3528.  
  3529.    if (purge == 'y' && strcmp(buf3,"localhost") == 0)
  3530.       {
  3531.       Verbose("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
  3532.       Verbose("!! Purge detected in local (non-cfd) file copy to file %s\n",ptr->destination);
  3533.       Verbose("!! Do not risk purge if source %s is NFS mounted (see manual)\n",ptr->path);
  3534.       Verbose("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
  3535.       }
  3536.  
  3537.    ptr->acl_aliases = VACLBUILD;
  3538.    
  3539.    if (strcmp(buf3,"localhost") != 0)
  3540.       {
  3541.       if ((hp = gethostbyname(buf3)) == NULL)
  3542.      {
  3543.      yyerror("DNS lookup failure. Unknown host");
  3544.      printf("Culprit: %s\n",server);
  3545.      printf("Make sure that fully qualified names can be looked up at your site!\n");
  3546.      printf("i.e. prep.ai.mit.edu, not just prep. If you use NIS or /etc/hosts\n");
  3547.      printf("make sure that the full form is registered too as an alias!\n");
  3548.      perror("gethostbyname: ");
  3549.      exit(1);
  3550.      }
  3551.       
  3552.       ptr->dns = (struct in_addr *) malloc(sizeof(struct in_addr));
  3553.       
  3554.       bcopy((hp->h_addr),(ptr->dns),sizeof(struct in_addr));
  3555.       }
  3556.    else
  3557.       {
  3558.       ptr->dns = NULL;
  3559.       }
  3560.    
  3561.    ptr->inode_cache = NULL;
  3562.    
  3563.    VIMAGETOP = ptr;
  3564.  
  3565.    AddInstallable(ptr->defines);
  3566.  
  3567.    if (!IsItemIn(VSERVERLIST,ptr->server))   /* cache list of servers */
  3568.       {
  3569.       AppendItem(&VSERVERLIST,ptr->server,NULL);
  3570.       }
  3571.    }
  3572.  
  3573. /* Add to possible classes so actions will be installed */
  3574.  
  3575.    
  3576. Delete2DList(tp);
  3577.  
  3578. InitializeAction();
  3579. }
  3580.  
  3581. /*******************************************************************/
  3582.  
  3583. InstallAuthItem(path,attribute,list,listtop,classes)
  3584.  
  3585. char *path, *attribute, *classes;
  3586. struct Auth **list, **listtop;
  3587.  
  3588. { struct TwoDimList *tp = NULL;
  3589.   char *sp;
  3590.  
  3591. Debug1("InstallAuthItem(%s,%s)\n",path,attribute);
  3592.  
  3593. Build2DListFromVarstring(&tp,path,'/');
  3594.    
  3595. Set2DList(tp);
  3596.  
  3597. for (sp = Get2DListEnt(tp); sp != NULL; sp = Get2DListEnt(tp))
  3598.    {
  3599.    if (AuthPathExists(sp,*list))
  3600.       {
  3601.       AddAuthHostItem(sp,attribute,classes,list);
  3602.       }
  3603.    else
  3604.       {
  3605.       InstallAuthPath(sp,attribute,classes,list,listtop);
  3606.       }
  3607.    }
  3608.  
  3609. Delete2DList(tp);
  3610. }
  3611.  
  3612. /*******************************************************************/
  3613.  
  3614. GetCommAttribute(s)
  3615.  
  3616. char *s;
  3617.  
  3618. { int i;
  3619.   char comm[maxvarsize];
  3620.  
  3621. for (i = 0; s[i] != '\0'; i++)
  3622.    {
  3623.    s[i] = ToLower(s[i]);
  3624.    }
  3625.  
  3626. comm[0]='\0';
  3627.  
  3628. sscanf(s,"%[^=]",comm);
  3629.  
  3630. Debug1("GetCommAttribute(%s)\n",comm);
  3631.  
  3632. for (i = 0; COMMATTRIBUTES[i] != NULL; i++)
  3633.    {
  3634.    if (strncmp(COMMATTRIBUTES[i],comm,strlen(comm)) == 0)
  3635.       {
  3636.       Debug1("GetCommAttribute - got: %s\n",COMMATTRIBUTES[i]);
  3637.       return i;
  3638.       }
  3639.    }
  3640.  
  3641. return cfbad;
  3642. }
  3643.  
  3644. /*******************************************************************/
  3645.  
  3646. HandleRecurse(value)
  3647.  
  3648. char *value;
  3649.  
  3650. { int n = -1;
  3651.  
  3652. if (strcmp(value,"inf") == 0)
  3653.    {
  3654.    VRECURSE = INFINITERECURSE;
  3655.    }
  3656. else
  3657.    {
  3658.    if (strncmp(CURRENTPATH,"home",4) == 0)
  3659.       {
  3660.       yyerror("Recursion is always infinite for home");
  3661.       return;
  3662.       }
  3663.  
  3664.    sscanf(value,"%d",&n);
  3665.  
  3666.    if (n == -1)
  3667.       {
  3668.       yyerror("Illegal recursion specifier");
  3669.       }
  3670.    else
  3671.       {
  3672.       VRECURSE = n;
  3673.       }
  3674.    }
  3675. }
  3676.  
  3677. /*******************************************************************/
  3678.  
  3679. HandleCopyType(value)
  3680.  
  3681. char *value;
  3682.  
  3683. {
  3684. if (strcmp(value,"ctime") == 0)
  3685.    {
  3686.    Debug1("Set copy by ctime\n");
  3687.    COPYTYPE = 't';
  3688.    return;
  3689.    }
  3690. else if (strcmp(value,"mtime") == 0)
  3691.    {
  3692.    Debug1("Set copy by mtime\n");
  3693.    COPYTYPE = 'm';
  3694.    return;
  3695.    }
  3696.  else if (strcmp(value,"checksum")==0 || strcmp(value,"sum") == 0)
  3697.    {
  3698.    Debug1("Set copy by md5 checksum\n");
  3699.    COPYTYPE = 'c';
  3700.    return;
  3701.    }
  3702. else if (strcmp(value,"byte")==0 || strcmp(value,"binary") == 0)
  3703.    {
  3704.    Debug1("Set copy by byte comaprison\n");
  3705.    COPYTYPE = 'b';
  3706.    return;
  3707.    }
  3708. yyerror("Illegal copy type");
  3709. }
  3710.  
  3711. /*******************************************************************/
  3712.  
  3713. HandleDisableFileType(value)
  3714.  
  3715. char *value;
  3716.  
  3717. {
  3718. if (strlen(CURRENTITEM) != 0)
  3719.    {
  3720.    Warning("Redefinition of filetype in disable");
  3721.    }
  3722.  
  3723. if (strcmp(value,"link") == 0 || strcmp(value,"links") == 0)
  3724.    {
  3725.    strcpy(CURRENTITEM,"link");
  3726.    }
  3727. else if (strcmp(value,"plain") == 0 || strcmp(value,"file") == 0)
  3728.    {
  3729.    strcpy(CURRENTITEM,"file");
  3730.    }
  3731. else
  3732.    {
  3733.    yyerror("Disable filetype unknown");
  3734.    }
  3735. }
  3736.  
  3737. /*******************************************************************/
  3738.  
  3739. HandleDisableRotate(value)
  3740.  
  3741. char *value;
  3742.  
  3743. { int num = 0;
  3744.  
  3745. if (strcmp(value,"empty") == 0 || strcmp(value,"truncate") == 0)
  3746.    {
  3747.    ROTATE = CF_TRUNCATE;
  3748.    }
  3749. else
  3750.    {
  3751.    sscanf(value,"%d",&num);
  3752.  
  3753.    if (num == 0)
  3754.       {
  3755.       yyerror("disable/rotate value must be a decimal number greater than zero or keyword empty");
  3756.       }
  3757.  
  3758.    if (! SILENT && num > 99)
  3759.       {
  3760.       Warning("rotate value looks silly");
  3761.       }
  3762.  
  3763.    ROTATE = (short) num;
  3764.    }
  3765. }
  3766.  
  3767. /*******************************************************************/
  3768.  
  3769. HandleAge(days)
  3770.  
  3771. char *days;
  3772.  
  3773. { 
  3774. sscanf(days,"%d",&VAGE);
  3775. Debug1("HandleAge(%d)\n",VAGE);
  3776. }
  3777.  
  3778. /*******************************************************************/
  3779.  
  3780. HandleProcessMatches(value)
  3781.  
  3782. char *value;
  3783.  
  3784. { int i = -1;
  3785.  
  3786. switch (*value)
  3787.    {
  3788.    case '>': PROCOMP = '>';
  3789.              value++;
  3790.              break;
  3791.    case '<': PROCOMP = '<';
  3792.              value++;
  3793.              break;
  3794.    default : PROCOMP = '=';
  3795.    }
  3796.  
  3797. sscanf(value,"%d",&i);
  3798.  
  3799. if (i < 0) 
  3800.    {
  3801.    yyerror("matches attribute with silly value (must be >= 0)");
  3802.    }
  3803.  
  3804. PROMATCHES = (short) i;
  3805. }
  3806.  
  3807. /*******************************************************************/
  3808.  
  3809. HandleProcessSignal(value)
  3810.  
  3811. char *value;
  3812.  
  3813. { int i;
  3814.   char *sp;
  3815.  
  3816. for (i = 1; SIGNALS[i] != 0; i++)
  3817.    {
  3818.    for (sp = value; *sp != '\0'; sp++)
  3819.       {
  3820.       *sp = ToUpper(*sp);
  3821.       }
  3822.    
  3823.    if (strcmp(SIGNALS[i]+3,value) == 0)  /* 3 to cut off "sig" */
  3824.       {
  3825.       PROSIGNAL = (short) i;
  3826.       return;
  3827.       }
  3828.    }
  3829.  
  3830. i = 0;
  3831.  
  3832. sscanf(value,"%d",&i);
  3833.  
  3834. if (i < 1 && i > highest_signal)
  3835.    {
  3836.    yyerror("Unknown signal in attribute");
  3837.    }
  3838.  
  3839. PROSIGNAL = (short) i;
  3840. }
  3841.  
  3842. /*******************************************************************/
  3843.  
  3844. HandleNetmask(value)
  3845.  
  3846. char *value;
  3847.  
  3848. {
  3849.  if (strlen(DESTINATION) == 0)
  3850.     {
  3851.     strcpy(DESTINATION,value);
  3852.     }
  3853.  else
  3854.     {
  3855.     yyerror("redefinition of netmask");
  3856.     }
  3857. }
  3858.  
  3859. /*******************************************************************/
  3860.  
  3861. HandleBroadcast(value)
  3862.  
  3863. char *value;
  3864.  
  3865. {
  3866. if (strlen(CURRENTPATH) != 0)
  3867.     {
  3868.     yyerror("redefinition of broadcast address");
  3869.     }
  3870.  
  3871. if (strcmp("ones",value) == 0)
  3872.    {
  3873.    strcpy(CURRENTPATH,"one");
  3874.    return;
  3875.    }
  3876.  
  3877. if (strcmp("zeroes",value) == 0)
  3878.    {
  3879.    strcpy(CURRENTPATH,"zero");
  3880.    return;
  3881.    }
  3882.  
  3883. if (strcmp("zeros",value) == 0)
  3884.    {
  3885.    strcpy(CURRENTPATH,"zero");
  3886.    return;
  3887.    }
  3888.  
  3889. yyerror("Illegal broadcast specifier (ones/zeros)"); 
  3890. }
  3891.  
  3892. /*******************************************************************/
  3893.  
  3894. AppendToActionSequence (action)
  3895.  
  3896. char *action;
  3897.  
  3898. { int j = 0;
  3899.   char *sp,cbuff[bufsize],actiontxt[bufsize];
  3900.  
  3901. Debug1("Installing item (%s) in the action sequence list\n",action);
  3902.  
  3903. AppendItem(&VACTIONSEQ,action,CLASSBUFF);
  3904.  
  3905. cbuff[0]='\0';
  3906. actiontxt[0]='\0';
  3907. sp = action;
  3908.  
  3909. while (*sp != '\0')
  3910.    {
  3911.    ++j;
  3912.    sscanf(sp,"%[^.]",cbuff);
  3913.  
  3914.    while ((*sp != '\0') && (*sp !='.'))
  3915.       {
  3916.       sp++;
  3917.       }
  3918.  
  3919.    if (*sp == '.')
  3920.       {
  3921.       sp++;
  3922.       }
  3923.  
  3924.    if (IsHardClass(cbuff))
  3925.       {
  3926.       yyerror("Error in action sequence: %s\n",action);
  3927.       yyerror("You cannot add a reserved class!");
  3928.       return;
  3929.       }
  3930.  
  3931.    if (j == 1)
  3932.       {
  3933.       strcpy(actiontxt,cbuff);
  3934.       continue;
  3935.       }
  3936.    else if ((!IsSpecialClass(cbuff)) && (!IsItemIn(VALLADDCLASSES,cbuff)))
  3937.       {
  3938.       AppendItem(&VALLADDCLASSES,cbuff,NULL);
  3939.       }
  3940.    }
  3941. }
  3942.  
  3943. /*******************************************************************/
  3944.  
  3945. AppendToAccessList (user)
  3946.  
  3947. char *user;
  3948.  
  3949. { char id[maxvarsize];
  3950.   struct passwd *pw;
  3951.  
  3952. Debug1("Adding to access list for %s\n",user);
  3953.  
  3954. if (isalpha(user[0]))
  3955.    {
  3956.    if ((pw = getpwnam(user)) == NULL)
  3957.       {
  3958.       yyerror("No such user in password database");
  3959.       return;
  3960.       }
  3961.  
  3962.    sprintf(id,"%d",pw->pw_uid);
  3963.    AppendItem(&VACCESSLIST,id,NULL);
  3964.    }
  3965. else
  3966.    {
  3967.    AppendItem(&VACCESSLIST,user,NULL);
  3968.    }
  3969. }
  3970.  
  3971. /*******************************************************************/
  3972.  
  3973. HandleLinkAction(value)
  3974.  
  3975. char *value;
  3976.  
  3977. {
  3978. if (strcmp(value,"silent") == 0)
  3979.    {
  3980.    LINKSILENT = true;
  3981.    return;
  3982.    }
  3983.  
  3984. yyerror("Invalid link action");
  3985. }
  3986.  
  3987. /*******************************************************************/
  3988.  
  3989. HandleDeadLinks(value)
  3990.  
  3991. char *value;
  3992.  
  3993. {
  3994. if (strcmp(value,"kill") == 0)
  3995.    {
  3996.    DEADLINKS = false;
  3997.    return;
  3998.    }
  3999.  
  4000. if (strcmp(value,"force") == 0)
  4001.    {
  4002.    DEADLINKS = true;
  4003.    return;
  4004.    }
  4005.  
  4006. yyerror("Invalid deadlink option");
  4007. }
  4008.  
  4009. /*******************************************************************/
  4010.  
  4011. HandleLinkType(value)
  4012.  
  4013. char *value;
  4014.  
  4015. {
  4016. if (strcmp(value,"hard") == 0)
  4017.    {
  4018.    if (ACTION_IS_LINKCHILDREN)
  4019.       {
  4020.       yyerror("hard links inappropriate for multiple linkage");
  4021.       }
  4022.  
  4023.    if (ACTION == image)
  4024.       {
  4025.       yyerror("hard links inappropriate for copy operation");
  4026.       }
  4027.  
  4028.    LINKTYPE = 'h';
  4029.    return;
  4030.    }
  4031.  
  4032. if (strcmp(value,"symbolic") == 0 || strcmp(value,"sym") == 0)
  4033.    {
  4034.    LINKTYPE = 's';
  4035.    return;
  4036.    }
  4037.  
  4038. if (strcmp(value,"abs") == 0 || strcmp(value,"absolute") == 0)
  4039.    {
  4040.    LINKTYPE = 'a';
  4041.    return;
  4042.    }
  4043.  
  4044. if (strcmp(value,"rel") == 0 || strcmp(value,"relative") == 0)
  4045.    {
  4046.    LINKTYPE = 'r';
  4047.    return;
  4048.    }
  4049.  
  4050. if (strcmp(value,"none") == 0 || strcmp(value,"copy") == 0)
  4051.    {
  4052.    LINKTYPE = 'n';
  4053.    return;
  4054.    }
  4055.  
  4056.  sprintf(OUTPUT,"Invalid link type %s\n",value);
  4057. yyerror(OUTPUT);
  4058. }
  4059.  
  4060. /*******************************************************************/
  4061.  
  4062. HandleServer(value)
  4063.  
  4064. char *value;
  4065.  
  4066. {
  4067. Debug("Server in copy set to : %s\n",value);
  4068. strcpy(CFSERVER,value);
  4069. }
  4070.  
  4071. /*******************************************************************/
  4072.  
  4073. HandleDefine(value)
  4074.  
  4075. char *value;
  4076.  
  4077. { char *sp;
  4078.  
  4079. Debug("Define response classes: %s\n",value);
  4080.  
  4081. if (strlen(value) > bufsize)
  4082.    {
  4083.    yyerror("class list too long in copy action - can't handle it!");
  4084.    }
  4085.  
  4086. strcpy(ALLCLASSBUFFER,value);
  4087.  
  4088. for (sp = value; *sp != '\0'; sp++)
  4089.    {
  4090.    if (*sp == ':' || *sp == ',' || *sp == '.')
  4091.       {
  4092.       continue;
  4093.       }
  4094.    
  4095.    if (! isalnum(*sp) && *sp != '_')
  4096.       {
  4097.       sprintf(OUTPUT,"Illegal class list in define=%s\n",value);
  4098.       yyerror(OUTPUT);
  4099.       }
  4100.    }
  4101. }
  4102.  
  4103.  
  4104. /*******************************************************************/
  4105. /* Level 4                                                         */
  4106. /*******************************************************************/
  4107.  
  4108. struct UidList *MakeUidList(uidnames)
  4109.  
  4110. char *uidnames;
  4111.  
  4112. { struct UidList *uidlist;
  4113.   struct Item *ip, *tmplist;
  4114.   char uidbuff[bufsize];
  4115.   char *sp;
  4116.   int offset;
  4117.   struct passwd *pw;
  4118.   char *machine, *user, *domain, buffer[bufsize];
  4119.   int uid;
  4120.   int tmp;
  4121.  
  4122. uidlist = NULL;
  4123. buffer[0] = '\0';
  4124.  
  4125. ExpandVarstring(uidnames,buffer,"");
  4126.  
  4127. for (sp = buffer; *sp != '\0'; sp+=strlen(uidbuff))
  4128.    {
  4129.    if (*sp == ',')
  4130.       {
  4131.       sp++;
  4132.       }
  4133.  
  4134.    if (sscanf(sp,"%[^,]",uidbuff))
  4135.       {
  4136.       if (uidbuff[0] == '+')        /* NIS group - have to do this in a roundabout     */
  4137.          {                          /* way because calling getpwnam spoils getnetgrent */
  4138.          offset = 1;
  4139.          if (uidbuff[1] == '@')
  4140.             {
  4141.             offset++;
  4142.             }
  4143.  
  4144.          setnetgrent(uidbuff+offset);
  4145.          tmplist = NULL;
  4146.  
  4147.          while (getnetgrent(&machine,&user,&domain))
  4148.             {
  4149.             if (user != NULL)
  4150.                {
  4151.                AppendItem(&tmplist,user,NULL);
  4152.                }
  4153.             }
  4154.                    
  4155.          endnetgrent();
  4156.  
  4157.          for (ip = tmplist; ip != NULL; ip=ip->next)
  4158.             {
  4159.             if ((pw = getpwnam(ip->name)) == NULL)
  4160.                {
  4161.            sprintf(OUTPUT,"Unknown user [%s]\n",ip->name);
  4162.            CfLog(cfverbose,OUTPUT,"getpwnam");
  4163.                continue;
  4164.                }
  4165.             else
  4166.                {
  4167.                uid = pw->pw_uid;
  4168.                }
  4169.             AddSimpleUidItem(&uidlist,uid); 
  4170.             }
  4171.  
  4172.          DeleteItemList(tmplist);
  4173.          continue;
  4174.          }
  4175.  
  4176.       if (isdigit(uidbuff[0]))
  4177.          {
  4178.          sscanf(uidbuff,"%d",&tmp);
  4179.          uid = (uid_t)tmp;
  4180.          }
  4181.       else
  4182.          {
  4183.          if (strcmp(uidbuff,"*") == 0)
  4184.             {
  4185.             uid = -1;                     /* signals wildcard */
  4186.             }
  4187.          else if ((pw = getpwnam(uidbuff)) == NULL)
  4188.             {
  4189.             printf("Unknown user %s\n",uidbuff);
  4190.             Warning("User is not known in this passwd domain");
  4191.             continue;
  4192.             }
  4193.          else
  4194.             {
  4195.             uid = pw->pw_uid;
  4196.             }
  4197.          }
  4198.       AddSimpleUidItem(&uidlist,uid);
  4199.       }
  4200.    }
  4201.  
  4202. if (uidlist == NULL)
  4203.    {
  4204.    AddSimpleUidItem(&uidlist,(uid_t) -1);
  4205.    }
  4206.  
  4207. return (uidlist);
  4208. }
  4209.  
  4210. /*********************************************************************/
  4211.  
  4212. struct GidList *MakeGidList(gidnames)
  4213.  
  4214. char *gidnames;
  4215.  
  4216. { struct GidList *gidlist;
  4217.   char gidbuff[bufsize],buffer[bufsize];
  4218.   char err[bufsize];
  4219.   char *sp;
  4220.   struct group *gr;
  4221.   int gid;
  4222.   int tmp;
  4223.  
  4224. gidlist = NULL;
  4225. buffer[0] = '\0';
  4226.  
  4227. ExpandVarstring(gidnames,buffer,"");
  4228.  
  4229. for (sp = buffer; *sp != '\0'; sp+=strlen(gidbuff))
  4230.    {
  4231.    if (*sp == ',')
  4232.       {
  4233.       sp++;
  4234.       }
  4235.  
  4236.    if (sscanf(sp,"%[^,]",gidbuff))
  4237.       {
  4238.       if (isdigit(gidbuff[0]))
  4239.          {
  4240.          sscanf(gidbuff,"%d",&tmp);
  4241.          gid = (gid_t)tmp;
  4242.          }
  4243.       else
  4244.          {
  4245.          if (strcmp(gidbuff,"*") == 0)
  4246.             {
  4247.             gid = -1;                     /* signals wildcard */
  4248.             }
  4249.          else if ((gr = getgrnam(gidbuff)) == NULL)
  4250.             {
  4251.             sprintf(err,"Unknown group %s\n",gidbuff);
  4252.             Warning(err);
  4253.             continue;
  4254.             }
  4255.          else
  4256.             {
  4257.             gid = gr->gr_gid;
  4258.             }
  4259.          }
  4260.       AddSimpleGidItem(&gidlist,gid);
  4261.       }
  4262.    }
  4263.  
  4264. if (gidlist == NULL)
  4265.    {
  4266.    AddSimpleGidItem(&gidlist,(gid_t) -1);
  4267.    }
  4268.  
  4269. return(gidlist);
  4270. }
  4271.  
  4272.  
  4273. /*******************************************************************/
  4274.  
  4275. InstallTidyPath(path,wild,rec,age,travlinks,tidysize,type,ldirs,tidydirs,classes,defines)
  4276.  
  4277. char *wild, *path, *defines;
  4278. short age,tidydirs;
  4279. int rec, tidysize;
  4280. char type, ldirs, *classes, travlinks;
  4281.  
  4282. { struct Tidy *ptr;
  4283.   char *sp;
  4284.   int no_of_links = 0;
  4285.  
  4286. if (!IsInstallable(classes))
  4287.    {
  4288.    InitializeAction();
  4289.    Debug1("Not installing tidy path, no match\n");
  4290.    return;
  4291.    }
  4292.  
  4293. VBUFF[0]='\0';                                /* Expand any variables */
  4294. ExpandVarstring(path,VBUFF,"");
  4295.  
  4296. if (strlen(VBUFF) != 1)
  4297.    {
  4298.    DeleteSlash(VBUFF);
  4299.    }
  4300.  
  4301. if ((ptr = (struct Tidy *)malloc(sizeof(struct Tidy))) == NULL)
  4302.    {
  4303.    FatalError("Memory Allocation failed for InstallTidyItem() #1");
  4304.    }
  4305.  
  4306. if ((ptr->path = strdup(VBUFF)) == NULL)
  4307.    {
  4308.    FatalError("Memory Allocation failed for InstallTidyItem() #3");
  4309.    }
  4310.  
  4311. if (VTIDYTOP == NULL)                 /* First element in the list */
  4312.    {
  4313.    VTIDY = ptr;
  4314.    }
  4315. else
  4316.    {
  4317.    VTIDYTOP->next = ptr;
  4318.    }
  4319.  
  4320. if (rec != INFINITERECURSE && strncmp("home/",ptr->path,5) == 0) /* Is this a subdir of home wildcard? */
  4321.    {
  4322.    for (sp = ptr->path; *sp != '\0'; sp++)                     /* Need to make recursion relative to start */
  4323.       {                                                        /* of the search, not relative to home */
  4324.       if (*sp == '/')
  4325.          {
  4326.          no_of_links++;
  4327.          }
  4328.       }
  4329.    }
  4330.  
  4331. ptr->tidylist = NULL;
  4332. ptr->recurse = rec + no_of_links;
  4333. ptr->next = NULL;
  4334.  
  4335. VTIDYTOP = ptr;
  4336.  
  4337. AddTidyItem(path,wild,rec,age,travlinks,tidysize,type,ldirs,tidydirs,classes,defines);
  4338. }
  4339.  
  4340. /*********************************************************************/
  4341.  
  4342. AddTidyItem(path,wild,rec,age,travlinks,tidysize,type,ldirs,tidydirs,classes,defines)
  4343.  
  4344. char *wild, *path, *defines;
  4345. short age,tidydirs;
  4346. int rec,tidysize;
  4347. char type, ldirs,*classes, travlinks;
  4348.  
  4349. { char varbuff[bufsize];
  4350.   struct Tidy *ptr;
  4351.  
  4352. Debug1("AddTidyItem(%s,pat=%s,size=%d)\n",path,wild,tidysize);
  4353.  
  4354. if ( ! IsInstallable(CLASSBUFF))
  4355.    {
  4356.    InitializeAction();
  4357.    Debug1("Not installing TidyItem no match\n");
  4358.    return;
  4359.    }
  4360.  
  4361. for (ptr = VTIDY; ptr != NULL; ptr=ptr->next)
  4362.    {
  4363.    varbuff[0] = '\0';
  4364.    ExpandVarstring(path,varbuff,"");
  4365.  
  4366.    if (strcmp(ptr->path,varbuff) == 0)
  4367.       {
  4368.       PrependTidy(&(ptr->tidylist),wild,rec,age,travlinks,tidysize,type,ldirs,tidydirs,classes,defines);
  4369.       
  4370.       /* Must have the maximum recursion level here */
  4371.       
  4372.       if (rec == INFINITERECURSE || (ptr->recurse < rec && ptr->recurse != INFINITERECURSE))
  4373.      {
  4374.          ptr->recurse = rec;
  4375.      }
  4376.       return;
  4377.       }
  4378.    }
  4379. }
  4380.  
  4381. /*********************************************************************/
  4382.  
  4383. TidyPathExists(path)
  4384.  
  4385. char *path;
  4386.  
  4387. { struct Tidy *tp;
  4388.  
  4389. VBUFF[0]='\0';                                /* Expand any variables */
  4390. ExpandVarstring(path,VBUFF,"");
  4391.  
  4392. for (tp = VTIDY; tp != NULL; tp=tp->next)
  4393.    {
  4394.    if (strcmp(tp->path,path) == 0)
  4395.       {
  4396.       Debug1("TidyPathExists(%s)\n",path);
  4397.       return true;
  4398.       }
  4399.    }
  4400.  
  4401. return false;
  4402. }
  4403.  
  4404.  
  4405. /*******************************************************************/
  4406. /* Level 5                                                         */
  4407. /*******************************************************************/
  4408.  
  4409. AddSimpleUidItem(uidlist,uid)
  4410.  
  4411. struct UidList **uidlist;
  4412. int uid;
  4413.  
  4414. { struct UidList *ulp, *u;
  4415.  
  4416. if ((ulp = (struct UidList *)malloc(sizeof(struct UidList))) == NULL)
  4417.    {
  4418.    FatalError("cfengine: malloc() failed #1 in AddSimpleUidItem()");
  4419.    }
  4420.  
  4421. ulp->uid = uid;
  4422. ulp->next = NULL;
  4423.  
  4424. if (*uidlist == NULL)
  4425.    {
  4426.    *uidlist = ulp;
  4427.    }
  4428. else
  4429.    {
  4430.    for (u = *uidlist; u->next != NULL; u = u->next)
  4431.       {
  4432.       }
  4433.    u->next = ulp;
  4434.    }
  4435. }
  4436.  
  4437. /*******************************************************************/
  4438.  
  4439. AddSimpleGidItem(gidlist,gid)
  4440.  
  4441. struct GidList **gidlist;
  4442. int gid;
  4443.  
  4444. { struct GidList *glp,*g;
  4445.  
  4446. if ((glp = (struct GidList *)malloc(sizeof(struct GidList))) == NULL)
  4447.    {
  4448.    FatalError("cfengine: malloc() failed #1 in AddSimpleGidItem()");
  4449.    }
  4450.  
  4451. glp->gid = gid;
  4452. glp->next = NULL;
  4453.  
  4454. if (*gidlist == NULL)
  4455.    {
  4456.    *gidlist = glp;
  4457.    }
  4458. else
  4459.    {
  4460.    for (g = *gidlist; g->next != NULL; g = g->next)
  4461.       {
  4462.       }
  4463.    g->next = glp;
  4464.    }
  4465. }
  4466.  
  4467.  
  4468. /***********************************************************************/
  4469.  
  4470. InstallAuthPath(path,hostname,classes,list,listtop)
  4471.  
  4472. char *path, *hostname, *classes;
  4473. struct Auth **list, **listtop;
  4474.  
  4475. { struct Auth *ptr;
  4476.  
  4477. if (!IsInstallable(classes))
  4478.    {
  4479.    Debug1("Not installing Auth path, no match\n");
  4480.    return;
  4481.    }
  4482.  
  4483. Debug1("InstallAuthPath(%s,%s)\n",path,hostname);
  4484.  
  4485. VBUFF[0]='\0';                                /* Expand any variables */
  4486. ExpandVarstring(path,VBUFF,"");
  4487.  
  4488. if (strlen(VBUFF) != 1)
  4489.    {
  4490.    DeleteSlash(VBUFF);
  4491.    }
  4492.  
  4493. if ((ptr = (struct Auth *)malloc(sizeof(struct Auth))) == NULL)
  4494.    {
  4495.    FatalError("Memory Allocation failed for InstallAuthPath() #1");
  4496.    }
  4497.  
  4498. if ((ptr->path = strdup(VBUFF)) == NULL)
  4499.    {
  4500.    FatalError("Memory Allocation failed for InstallAuthPath() #3");
  4501.    }
  4502.  
  4503. if (*listtop == NULL)                 /* First element in the list */
  4504.    {
  4505.    *list = ptr;
  4506.    }
  4507. else
  4508.    {
  4509.    (*listtop)->next = ptr;
  4510.    }
  4511.  
  4512. ptr->accesslist = NULL;
  4513. ptr->maproot = NULL;
  4514. ptr->secure = false; 
  4515. ptr->next = NULL;
  4516. *listtop = ptr;
  4517.  
  4518. AddAuthHostItem(ptr->path,hostname,classes,list);
  4519. }
  4520.  
  4521. /***********************************************************************/
  4522.  
  4523. AddAuthHostItem(path,attribute,classes,list)
  4524.  
  4525. char *path, *attribute, *classes;
  4526. struct Auth **list;
  4527.  
  4528. { char varbuff[bufsize];
  4529.   struct Auth *ptr;
  4530.  
  4531. Debug1("AppendAuthHostItem(%s,%s)\n",path,attribute);
  4532.  
  4533. if (!IsInstallable(CLASSBUFF))
  4534.    {
  4535.    Debug1("Not installing TidyItem no match\n");
  4536.    return;
  4537.    }
  4538.  
  4539. for (ptr = *list; ptr != NULL; ptr=ptr->next)
  4540.    {
  4541.    varbuff[0] = '\0';
  4542.    ExpandVarstring(path,varbuff,"");
  4543.  
  4544.    if (strcmp(ptr->path,varbuff) == 0)
  4545.       {
  4546.       if (!HandleAdmitAttribute(ptr,attribute))
  4547.      {
  4548.      PrependItem(&(ptr->accesslist),attribute,classes);
  4549.      }
  4550.       return;
  4551.       }
  4552.    }
  4553. }
  4554.  
  4555.  
  4556. /*********************************************************************/
  4557.  
  4558. AuthPathExists(path,list)
  4559.  
  4560. char *path;
  4561. struct Auth *list;
  4562.  
  4563. { struct Auth *ap;
  4564.  
  4565. Debug1("AuthPathExists(%s)\n",path);
  4566.  
  4567. VBUFF[0]='\0';                                /* Expand any variables */
  4568. ExpandVarstring(path,VBUFF,"");
  4569.  
  4570. if (VBUFF[0] != '/')
  4571.    {
  4572.    yyerror("Missing absolute path to a directory");
  4573.    FatalError("Cannot continue");
  4574.    }
  4575.  
  4576. for (ap = list; ap != NULL; ap=ap->next)
  4577.    {
  4578.    if (strcmp(ap->path,VBUFF) == 0)
  4579.       {
  4580.       return true;
  4581.       }
  4582.    }
  4583.  
  4584. return false;
  4585. }
  4586.  
  4587. /*********************************************************************/
  4588.  
  4589. HandleAdmitAttribute(ptr,attribute)
  4590.  
  4591. struct Auth *ptr;
  4592. char *attribute;
  4593.  
  4594. { char value[maxvarsize],buffer[bufsize],host[maxvarsize],*sp;
  4595.  
  4596. VBUFF[0] = value[0] = '\0';
  4597.  
  4598. ExpandVarstring(attribute,VBUFF,NULL);
  4599.  
  4600. sscanf(VBUFF,"%*[^=]=%s",value);
  4601.  
  4602. if (value[0] == '\0')
  4603.    {
  4604.    return false;
  4605.    }
  4606.  
  4607. Debug1("HandleOptionalFileAttribute(%s)\n",value);
  4608.  
  4609. switch(GetCommAttribute(attribute))
  4610.    {
  4611.    case cfsecure:  if ((strcmp(value,"on")==0) || (strcmp(value,"true")==0))
  4612.                       {
  4613.               ptr->secure = true;
  4614.               return true;
  4615.               }
  4616.                    break;
  4617.  
  4618.    case cfroot:   bzero(buffer,bufsize);
  4619.  
  4620.                   ExpandVarstring(value,buffer,"");
  4621.  
  4622.           for (sp = buffer; *sp != '\0'; sp+=strlen(host))
  4623.              {
  4624.              if (*sp == ',')
  4625.             {
  4626.             sp++;
  4627.             }
  4628.  
  4629.              host[0] = '\0';
  4630.              
  4631.              if (sscanf(sp,"%[^,]",host))
  4632.             {
  4633.             if (!strstr(host,"."))
  4634.                {
  4635.                if (strlen(host)+strlen(VDOMAIN) < maxvarsize-2)
  4636.                   {
  4637.                   strcat(host,".");
  4638.                   strcat(host,VDOMAIN);
  4639.                   }
  4640.                else
  4641.                   {
  4642.                   yyerror("Server name too long");
  4643.                   }
  4644.                }
  4645.             PrependItem(&(ptr->maproot),host,NULL);
  4646.             }
  4647.              }
  4648.           return true;
  4649.           break;
  4650.    }
  4651.  
  4652. yyerror("Illegal admit attribute"); 
  4653. return false;
  4654. }
  4655.  
  4656.  
  4657. /*********************************************************************/
  4658.  
  4659. PrependTidy(list,wild,rec,age,travlinks,tidysize,type,ldirs,tidydirs,classes,defines)
  4660.  
  4661. struct TidyPattern **list;
  4662. char *wild;
  4663. short age,tidydirs;
  4664. int rec,tidysize;
  4665. char type, ldirs, *classes, *defines, travlinks;
  4666.  
  4667. { struct TidyPattern *tp;
  4668.   char *spe,*sp, buffer[bufsize];
  4669.  
  4670. if ((tp = (struct TidyPattern *)malloc(sizeof(struct TidyPattern))) == NULL)
  4671.    {
  4672.    perror("Can't allocate memory in PrependTidy()");
  4673.    FatalError("");
  4674.    }
  4675.  
  4676. if ((sp = strdup(wild)) == NULL)
  4677.    {
  4678.    FatalError("Memory Allocation failed for PrependTidy() #2");
  4679.    }
  4680.  
  4681. bzero(buffer,bufsize);
  4682. ExpandVarstring(defines,buffer,""); 
  4683.  
  4684. if ((tp->defines = strdup(buffer)) == NULL)
  4685.    {
  4686.    FatalError("Memory Allocation failed for PrependTidy() #2a");
  4687.    }
  4688.  
  4689. AddInstallable(tp->defines); 
  4690.  
  4691. if ((classes!= NULL) && (spe = malloc(strlen(classes)+2)) == NULL)
  4692.    {
  4693.    perror("Can't allocate memory in PrependItem()");
  4694.    FatalError("");
  4695.    }
  4696.  
  4697. if (travlinks == '?')
  4698.    {
  4699.    travlinks = 'F';  /* False is default */
  4700.    }
  4701.  
  4702. tp->size = tidysize;
  4703. tp->recurse = rec;
  4704. tp->age = age;
  4705. tp->searchtype = type;
  4706. tp->travlinks = travlinks;
  4707. tp->pattern = sp;
  4708. tp->next = *list;
  4709. tp->dirlinks = ldirs;
  4710. tp->log = LOGP;
  4711. tp->inform = INFORMP;
  4712.  
  4713. switch (tidydirs)
  4714.    {
  4715.    case 0: tp->rmdirs = 'f';
  4716.            break;
  4717.    case 1: tp->rmdirs = 't';
  4718.            break;
  4719.    case 2: tp->rmdirs = 's';
  4720.            break;
  4721.    default: FatalError("Software error in Prepend Tidy");
  4722.    }
  4723.  
  4724. *list = tp;
  4725.  
  4726. if (classes != NULL)
  4727.    {
  4728.    strcpy(spe,classes);
  4729.    tp->classes = spe;
  4730.    }
  4731. else
  4732.    {
  4733.    tp->classes = NULL;
  4734.    }
  4735. }
  4736.  
  4737. /* EOF */
  4738.